Jak zarządzać użytkownikami i uwierzytelnianiem w MongoDB

Wprowadzenie

Zarządzanie użytkownikami i uwierzytelnianie to jedne z najważniejszych zadań administracyjnych związanych z zarządzaniem serwerami MongoDB. Musisz upewnić się, że serwer jest skonfigurowany tak, aby mógł prawidłowo identyfikować użytkowników i aplikacje oraz odmawiać połączeń lub operacji, które nie są w stanie poprawnie uwierzytelnić.

Aby zarządzać tymi wymaganiami, musisz mieć możliwość decydowania, jakich użytkowników wymaga twój serwer i tworzenia tych kont. W ramach tego procesu możesz ustawić szczegóły uwierzytelniania, aby umożliwić dostęp z zewnątrz przy użyciu nowej tożsamości.

W tym przewodniku omówimy tworzenie, przeglądanie i usuwanie kont użytkowników. Omówimy, jak skonfigurować uwierzytelnianie dla swoich kont i jak zaktualizować dane uwierzytelniające, gdy musisz zmienić hasła użytkownika.

Wymagania wstępne

Aby postępować zgodnie z tym przewodnikiem, potrzebujesz konta na serwerze MongoDB z odpowiednimi uprawnieniami.

Polecenia i metody, których będziemy używać

Podstawowe metody potrzebne do tworzenia, modyfikowania i usuwania użytkowników w MongoDB oraz konfigurowania uwierzytelniania to:

db.createUser :utwórz nowe konto użytkownika MongoDB
db.updateUser :zaktualizuj szczegóły konta użytkownika
db.changeUserPassword :zmień hasło używane przez konto użytkownika
db.dropUser :usuń konto użytkownika MongoDB

Dodatkowo, następujące polecenie bazy danych jest przydatne do wyszukiwania informacji o użytkownikach w systemie:

db.runCommand('usersInfo') :pokaż informacje o jednym lub więcej kontach użytkowników MongoDB

Wymagane uprawnienia

Aby wykonać powyższe polecenia, musisz zalogować się do MongoDB za pomocą konta z kilkoma różnymi uprawnieniami. Konkretne uprawnienia, których potrzebujesz, zależą od poleceń, których musisz użyć.

Aby uzyskać informacje o innych użytkownikach, Twój obecny użytkownik musi mieć włączone następujące uprawnienia:

viewUser Akcja przywilej

Aby utworzyć nowych użytkowników, Twój obecny użytkownik musi mieć włączone następujące uprawnienia:

createUser Akcja przywilej
grantRole Akcja przywilej

Aby zmienić hasło lub dane konta użytkownika, możesz potrzebować następujących uprawnień:

changeOwnPassword akcja uprawniająca do zmiany hasła do własnego konta
changeOwnCustomData akcja uprawniająca do zmiany niestandardowych danych własnego konta
changePassword akcja uprawniająca do zmiany haseł innych użytkowników
changeCustomData akcja uprawniająca do zmiany niestandardowych danych innych użytkowników

W tym przewodniku nie będziemy omawiać zarządzania rolami, więc grantRole i revokeRole działania związane z uprawnieniami nie są wymagane.

Aby usunąć konto użytkownika, Twój obecny użytkownik musi mieć włączone następujące uprawnienia:

dropUser Akcja przywilej

Zrozumienie, jak MongoDB implementuje użytkowników i uwierzytelnianie

Zanim zaczniemy tworzyć konta i zarządzać nimi, warto poświęcić trochę czasu na zapoznanie się ze sposobem, w jaki MongoDB definiuje i przechowuje te informacje.

W MongoDB konta użytkowników są kombinacją nazwy użytkownika konta wraz z określoną bazą danych uwierzytelniania. Baza danych uwierzytelniania to po prostu baza danych, w której zdefiniowany jest użytkownik i nie oznacza ograniczenia zakresu ani praw. Bazy danych uwierzytelniania to zwykłe bazy danych używane do zarządzania innymi danymi, a nie specjalne, dedykowane bazy danych.

Nazwa konta użytkownika musi być unikalna w jego bazie danych uwierzytelniania. Jednak ta sama nazwa użytkownika może zostać ponownie wykorzystana w innej bazie danych uwierzytelniania w celu utworzenia nowego, odrębnego konta użytkownika.

W wyniku tego projektu konto może być dokładnie zidentyfikowane tylko przez dołączenie nazwy użytkownika i bazy danych uwierzytelniania. Aby uwierzytelnić się na koncie, należy również podać dane uwierzytelniające powiązane z kontem. Zwykle jest to hasło, ale może to być również certyfikat.

Jak tworzyć użytkowników?

Teraz, gdy przyjrzeliśmy się, jak MongoDB konceptualizuje konta użytkowników, możemy omówić sposób tworzenia nowych użytkowników. Pamiętaj, aby zalogować się na serwer MongoDB jako użytkownik, który ma odpowiednie uprawnienia do śledzenia.

Aby utworzyć nowego użytkownika, musisz najpierw przełączyć się do bazy danych, której chcesz użyć jako bazy danych uwierzytelniania nowego użytkownika.

Najpierw możesz uzyskać listę baz danych, które są już skonfigurowane w Twoim systemie, wpisując:

show dbs

admin   0.000GBconfig  0.000GBlocal   0.000GB

Przejdź do bazy danych, z którą użytkownik będzie skojarzony za pomocą use polecenie:

use admin

switched to db admin

Aby utworzyć nowego użytkownika, możesz użyć funkcji db.createUser() lub możesz użyć createUser polecenie bazy danych. Tak czy inaczej, będziesz musiał przekazać nazwę użytkownika (user pole), hasło (pwd pole) oraz tablicę ról, do których użytkownik powinien zostać dodany (roles klucz) w ramach user obiekt.

Aby utworzyć nowego użytkownika o nazwie tom z hasłem ustawionym na hellothere z pustą tablicą ról za pomocą db.createUser() metody, możesz wpisać:

db.createUser({    user: "tom",    pwd: "hellothere",    roles: []})

Successfully added user: { "user" : "tom", "roles" : [ ] }

Ta sama operacja przy użyciu createUser polecenie bazy danych wyglądałoby tak:

db.runCommand({    createUser: "tom",    pwd: "hellothere",    roles: []})

Successfully added user: { "user" : "tom", "roles" : [ ] }

Te dwie różne opcje są bardzo podobne, więc będziemy pokazywać metody bazy danych tylko tam, gdzie ma to zastosowanie, w przyszłości. Jeśli jednak wolisz składnię poleceń bazy danych, możesz znaleźć każde z powiązanych poleceń w dokumentacji referencyjnej poleceń MongoDB.

W powyższych poleceniach wyraźnie zdefiniowaliśmy hasło wbudowane w user obiekt. Aby zapobiec rejestrowaniu i odzyskiwaniu hasła, możesz alternatywnie użyć passwordPrompt() metoda w user document, aby MongoDB interaktywnie wyświetlał monit o podanie hasła po uruchomieniu polecenia. Hasło nie będzie widoczne, więc historia poleceń będzie czysta:

db.createUser({    user: "tom",    pwd: passwordPrompt(),    roles: []})

Enter password:Successfully added user: { "user" : "tom", "roles" : [ ] }

Pamiętaj, że hasło będzie nadal wysyłane do serwera w postaci zwykłego tekstu, jeśli nie masz włączonej obsługi TLS/SSL.

Jak pokazać istniejących użytkowników?

Następnie przyjrzyjmy się, jak znaleźć informacje o istniejących użytkownikach.

Aby zwrócić wielu użytkowników, możesz użyć db.getUsers() metodę, aby pokazać wszystkich użytkowników w bieżącej bazie danych. Najpierw przejdź do bazy danych, którą chcesz przeszukać:

use admin

Następnie użyj db.getUsers() metoda zwracania wszystkich użytkowników powiązanych z bieżącą bazą danych:

db.getUsers()

[    {            "_id" : "admin.root",            "userId" : UUID("f5ded238-19c9-4886-b649-711ec36993cb"),            "user" : "root",            "db" : "admin",            "roles" : [                    {                            "role" : "root",                            "db" : "admin"                    }            ],            "mechanisms" : [                    "SCRAM-SHA-1",                    "SCRAM-SHA-256"            ]    },    {            "_id" : "admin.tom",            "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),            "user" : "tom",            "db" : "admin",            "roles" : [ ],            "mechanisms" : [                    "SCRAM-SHA-1",                    "SCRAM-SHA-256"            ]    }]

Aby dodatkowo pokazać informacje uwierzytelniające każdego użytkownika, przekaż obiekt do metody z showCredentials klucz do true :

use admindb.getUsers({    showCredentials: true})

[        {                "_id" : "admin.root",                . . .                "credentials" : {                        "SCRAM-SHA-1" : {                                "iterationCount" : 10000,                                "salt" : "WpB0H4f7dG8XlCDyaVzarA==",                                "storedKey" : "b11nA1+mGo3+Tr8P//u3NEdJLHk=",                                "serverKey" : "3xE8o663hjqySrMCQcXjSxmjmhk="                        },                        "SCRAM-SHA-256" : {                                "iterationCount" : 15000,                                "salt" : "UtsfNRedf2ek5tbWFoGs2g52U0H7Na44wV4rYA==",                                "storedKey" : "mz9/qHnI79pNAIQm0MZTKZ0U3qFk0xhUDd2grvKtMdI=",                                "serverKey" : "c/sA4j+I/29Ea1y07zxoMcBgHFoYTUAa6luX3Z9sToQ="                        }                },                . . .        },        {                "_id" : "admin.tom",                . . .                "credentials" : {                        "SCRAM-SHA-1" : {                                "iterationCount" : 10000,                                "salt" : "qCbxWQSGt3QoN3S1aM5AEg==",                                "storedKey" : "hypim5+m2wqbS1gc47o2itc7jew=",                                "serverKey" : "h9myNoSvY2015yqvw3UldmJzZCg="                        },                        "SCRAM-SHA-256" : {                                "iterationCount" : 15000,                                "salt" : "lNtIVL79J8FF+uPaFfRMwPK079gfLEUrsQe3Qg==",                                "storedKey" : "u8pgn3OJiZxIwEL7ryZkoAF5bnMefQEEsZDTXNDCTRY=",                                "serverKey" : "BmmfVeikSA0DN1aZmyZP9NXi5owxGr1ZRmVX2XH8qVg="                        }                },                . . .        }]

Aby zapytać o użytkowników spełniających określone kryteria, możesz przekazać obiekt, który definiuje filter klucz, który definiuje warunek dopasowania.

Na przykład, aby uzyskać informacje o wszystkich użytkownikach w bieżącej bazie danych, którzy mają root rolę, możesz wpisać:

use admindb.getUsers({    filter: {        "roles.role": "root"    }})

[        {                "_id" : "admin.root",                "userId" : UUID("f5ded238-19c9-4886-b649-711ec36993cb"),                "user" : "root",                "db" : "admin",                "roles" : [                        {                                "role" : "root",                                "db" : "admin"                        }                ],                "mechanisms" : [                        "SCRAM-SHA-1",                        "SCRAM-SHA-256"                ]        }]

Aby uzyskać konkretnego użytkownika, możesz użyć db.getUser() zamiast tego. Działa to jak db.getUsers() metody, ale zwraca jednego użytkownika. Zamiast przekazywać obiekt do metody, przekazujesz ciąg znaków zawierający nazwę użytkownika, którą chcesz pobrać:

use admindb.getUser("tom")

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "roles" : [ ],        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ]}

Opcjonalnie możesz dołączyć dodatkowe args obiekt, który pozwala określić dodatkowe informacje, które chcesz, ustawiając następujące klucze na true :

showCredentials :pokazuje informacje uwierzytelniające oprócz zwykłych danych wyjściowych
showPrivileges :pokazuje informacje o uprawnieniach oprócz zwykłego wyjścia
showAuthenticationRestrictions :pokazuje ograniczenia uwierzytelniania na koncie oprócz zwykłych danych wyjściowych

Na przykład możesz powiedzieć MongoDB, aby dostarczyła Ci wszystkie powyższe informacje, wpisując:

use admindb.getUser("tom",{    showCredentials: true,    showPrivileges: true,    showAuthenticationRestrictions: true})

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ],        "credentials" : {                "SCRAM-SHA-1" : {                        "iterationCount" : 10000,                        "salt" : "qCbxWQSGt3QoN3S1aM5AEg==",                        "storedKey" : "hypim5+m2wqbS1gc47o2itc7jew=",                        "serverKey" : "h9myNoSvY2015yqvw3UldmJzZCg="                },                "SCRAM-SHA-256" : {                        "iterationCount" : 15000,                        "salt" : "lNtIVL79J8FF+uPaFfRMwPK079gfLEUrsQe3Qg==",                        "storedKey" : "u8pgn3OJiZxIwEL7ryZkoAF5bnMefQEEsZDTXNDCTRY=",                        "serverKey" : "BmmfVeikSA0DN1aZmyZP9NXi5owxGr1ZRmVX2XH8qVg="                }        },        "roles" : [ ],        "inheritedRoles" : [ ],        "inheritedPrivileges" : [ ],        "inheritedAuthenticationRestrictions" : [ ],        "authenticationRestrictions" : [ ]}

Jak zmienić hasło dla użytkownika MongoDB?

Aby zmienić hasło użytkownika, możesz użyć db.changeUserPassword() metoda. Ponownie, musisz przełączyć się na bazę danych uwierzytelniania użytkownika przed wykonaniem polecenia.

db.changeUserPassword() Metoda przyjmuje dwa argumenty:nazwę użytkownika konta, które chcesz zmienić i nowe hasło do konta.

Na przykład, aby zmienić hasło dla użytkownika tom uwierzytelnione przez admin baza danych do secretpassword , możesz wpisać:

use admindb.changeUserPassword("tom", "secretpassword")

Podobnie jak w przypadku db.createUser() metody, możesz użyć passwordPrompt() metoda dla drugiego argumentu zamiast wpisywania hasła. MongoDB poprosi o podanie hasła po wykonaniu polecenia:

use admindb.changeUserPassword("tom", passwordPrompt())

Enter password:

Jak zmienić inne szczegóły konta użytkownika?

Aby zmienić inne informacje związane z kontem użytkownika, możesz użyć db.updateUser() metoda. Upewnij się, że przełączyłeś się do bazy danych uwierzytelniania użytkownika przed aktualizacją jego danych.

db.updateUser() Metoda wymaga podania nazwy użytkownika, a następnie podania obiektu zawierającego dane, które chcesz zaktualizować. Każde pole, które zdecydujesz się zaktualizować, zostanie całkowicie zastąpione nowymi informacjami, więc pamiętaj, aby uwzględnić w obiekcie zarówno oryginalne, jak i nowe dane, jeśli chcesz tylko dodać nowe informacje.

Obiekt, który zawierasz w poleceniu z informacją o zmianie, może zawierać wiele różnych pól. Przyjrzyjmy się im:

customData :Wszelkie dowolne dane, które mają być powiązane z kontem użytkownika.
roles :role przyznane użytkownikowi. Często lepiej jest użyć db.grantRolesToUser() i db.revokeRolesFromUser() metody kontrolowania członkostwa w rolach zamiast aktualizowania za pomocą tego klucza, ponieważ można indywidualnie dodawać i usuwać role.
pwd :Hasło użytkownika. Korzystanie z db.ChangeUserPassword() metoda jest zwykle łatwiejsza, jeśli jest to jedyne pole, które należy zaktualizować.
authenticationRestrictions :Określa ograniczenia dla konta, które mogą ograniczać adresy IP, z których użytkownicy mogą się łączyć. Wartość tego klucza to obiekt lub tablica, która definiuje clientSource i lub serverAddress , które zawierają tablice określające prawidłowe adresy IP lub zakresy. Dowiedz się więcej w dokumentacji MongoDB na temat ograniczeń uwierzytelniania.
mechanisms :Specyficzne mechanizmy uwierzytelniania używane do poświadczeń. Może być ustawiony na jeden lub oba z SCRAM-SHA-1 lub SCRAM-SHA-256 , ale można je zmienić tylko na podzbiór obecnych mechanizmów, jeśli nowe hasło nie jest aktualnie dostarczane.
passwordDigestor :Określa, który składnik przetwarza hasło użytkownika. Może być server (domyślnie) lub client .

Jako przykład możemy zaktualizować tom konto, które uwierzytelnia się przed admin bazy danych, aby móc zalogować się tylko z tego samego komputera, który obsługuje sam serwer, zmieniając authenticationRestrictions pole:

use admindb.updateUser("tom", {    authenticationRestrictions: [ {        clientSource: ["127.0.0.1", "::1"],        serverAddress: ["127.0.0.1", "::1"]    } ]})

Teraz, jeśli poprosisz MongoDB o pokazanie odpowiednich informacji o użytkowniku, wyświetli dodatkowe ograniczenia dla konta:

use admindb.getUser("tom", {    showAuthenticationRestrictions: true})

{        "_id" : "admin.tom",        "userId" : UUID("e7a0abde-a9f9-412a-bfd5-eb11fda41fd3"),        "user" : "tom",        "db" : "admin",        "mechanisms" : [                "SCRAM-SHA-1",                "SCRAM-SHA-256"        ],        "roles" : [ ],        "authenticationRestrictions" : [                {                        "clientSource" : [                                "127.0.0.1",                                "::1"                        ],                        "serverAddress" : [                                "127.0.0.1",                                "::1"                        ]                }        ],        "inheritedRoles" : [ ],        "inheritedPrivileges" : [ ],        "inheritedAuthenticationRestrictions" : [ ]}

Aby odwołać te ograniczenia, możemy ponownie uruchomić polecenie z pustą tablicą:

use admindb.changeUser("tom", {    authenticationRestrictions: []})

Jak usunąć użytkowników MongoDB?

Aby usunąć konta użytkowników MongoDB, możesz użyć db.dropUser() metoda. Pamiętaj, aby połączyć się z bazą danych uwierzytelniania użytkownika przed ich usunięciem.

Aby wykonać db.dropUser() metody, musisz podać nazwę użytkownika, którego chcesz usunąć:

db.dropUser("tom")

Po pomyślnym usunięciu MongoDB zwróci true :

true

Jeśli konto nie istnieje w bieżącej bazie danych, zamiast tego zwróci false .

Wniosek

Zarządzanie użytkownikami i konfiguracja uwierzytelniania MongoDB pozwala kontrolować, kto może łączyć się z Twoimi serwerami i jakie są ich właściwości użytkownika. W następnym artykule omówimy, jak ograniczyć poziom dostępu, jaki mają użytkownicy, zajmując się częścią związaną z autoryzacją zarządzania użytkownikami.