Início rápido para o operador Kubernetes

Importante

Esta seção é somente para sistemas de cluster Kubernetes únicos. Para sistemas do MongoDB em clusters multi-Kubernetes, consulte Visão geral.

O MongoDB Controllers para Kubernetes Operator usa a API e as ferramentas do Kubernetes para gerenciar clusters MongoDB em execução no cluster Kubernetes. O Kubernetes operador trabalha em conjunto com o Ops Manager. Este tutorial demonstra como implantar o MongoDB Ops Manager no Kubernetes e, em seguida, implantar e conectar ao seu primeiro conjunto de réplicas MongoDB com o Kubernetes Operator. Você pode usar o Kind para configurar rapidamente um cluster. Para saber mais, consulte o Kind.

Pré-requisitos

Este tutorial requer:

Um cluster Kubernetes em execução.
Helm instalado em sua máquina local.
Nós do Kubernetes em execução em arquiteturas de hardware compatíveis.
O shell do MongoDB instalado em sua máquina local.

Se você usar Kind com o Docker Desktop, aloque pelo menos 8 GB de memória e 4 CPUs nas configurações de recursos do Docker Desktop. O MongoDB Ops Manager requer um mínimo de 5 GB de memória para o aplicativo e recursos adicionais para o banco de dados de aplicativo e o operador Kubernetes.

Procedimento

Adicione o repositório MongoDB Helm Charts for Kubernetes ao Helm.

helm repo add mongodb https://mongodb.github.io/helm-charts

Instale os Controladores MongoDB para o Operador Kubernetes

Para instalar o Operador Kubernetes com Helm, consulte as instruções no repositório.

Exemplo

O seguinte comando instala os Controladores MongoDB para Operador Kubernetes no namespace do mongodb com a opção --create-namespace opcional. Por padrão, o Kubernetes Operator utiliza o namespace default.

helm install kubernetes-operator mongodb/mongodb-kubernetes --namespace mongodb --create-namespace

Configure `kubectl` como padrão para seu namespace.

Caso ainda não tenha feito isso, execute o seguinte comando para executar todos os comandos kubectl no namespace que você criou:

kubectl config set-context $(kubectl config current-context) --namespace=mongodb

Crie o segredo de credenciais de administrador do MongoDB Ops Manager.

Crie um segredo que contém as credenciais iniciais do usuário administrador do MongoDB Ops Manager. O operador Kubernetes usa esse segredo para configurar o primeiro usuário administrador ao implantar o recurso MongoDB Ops Manager.

Execute o seguinte comando, substituindo os valores do espaço reservado pelas suas credenciais preferidas:

kubectl create secret generic ops-manager-admin-secret \
  --from-literal=Username="<admin-email>" \
  --from-literal=Password="<admin-password>" \
  --from-literal=FirstName="<first-name>" \
  --from-literal=LastName="<last-name>"

Observação

Armazene essas credenciais com segurança. Você precisará delas para conectar-se à IU do MongoDB Ops Manager após a implantação.

Implante o recurso do MongoDB Ops Manager.

Copie e salve o seguinte arquivo YAML como ops-manager.yaml:

apiVersion: mongodb.com/v1
kind: MongoDBOpsManager
metadata:
  name: ops-manager
  namespace: mongodb
spec:
  replicas: 1
  version: "8.0.0"
  adminCredentials: ops-manager-admin-secret
  externalConnectivity:
    type: NodePort
  configuration:
    mms.ignoreInitialUiSetup: "true"
    automation.versions.source: "mongodb"
    mms.fromEmailAddr: admin@example.com
    mms.replyToEmailAddr: admin@example.com
    mms.adminEmailAddr: admin@example.com
    mms.mail.transport: smtp
    mms.mail.hostname: localhost
    mms.mail.port: "25"
  backup:
    enabled: false
  applicationDatabase:
    topology: SingleCluster
    members: 3
    version: "8.0.0"

Para saber mais, consulte a Especificação de recurso do MongoDB Ops Manager.

Execute o seguinte comando:
kubectl apply -f ops-manager.yaml

Aguarde o recurso do MongoDB Ops Manager atingir o estado de execução.

O operador Kubernetes primeiro implanta o conjunto de réplicas do banco de dados de aplicativo e, em seguida, inicia o aplicativo MongoDB Ops Manager. Esse processo pode levar vários minutos.

Execute o seguinte comando para acompanhar o status do recurso:

kubectl get om -o yaml -w

Aguarde até que a saída mostre as seguintes fases:

status:
  applicationDatabase:
    phase: Running
  opsManager:
    phase: Running

Quando ambos os componentes atingirem Running, recupere o URL do MongoDB Ops Manager:

kubectl get om ops-manager -o jsonpath='{.status.opsManager.url}'

Anote esta URL. Você precisará dela para o ConfigMap em uma etapa posterior.

Configure o operador Kubernetes para o MongoDB Ops Manager.

Você pode usar a IU do MongoDB Ops Manager para gerar o ConfigMap e o Secret, ou pode criá-los manualmente.

Primeiro, encaminhe a porta de serviço do MongoDB Ops Manager para sua máquina local para que você possa acessar a IU em seu navegador:

kubectl port-forward svc/ops-manager-svc-ext 8080:8080

Em seguida, abra http://localhost:8080 em seu navegador e conecte-se com as credenciais que você criou no segredo do administrador.

Para usar a IU do MongoDB Ops Manager:

Vá para a página de configuração do Kubernetes na IU do MongoDB Ops Manager.
Clique em Create New API Keys ou Use Existing API Keys.
Preencha o formulário. Para saber mais, consulte Criar Credenciais para o Operador Kubernetes.
Clique em Generate Key and YAML.

Como alternativa, você pode criar o ConfigMap e o Secret manualmente nas seguintes etapas.

Crie e salve o ConfigMap.

Se você gerou o ConfigMap na IU do Ops Manager, copie e salve o arquivo config-map.yaml gerado. Caso contrário, crie e salve o seguinte arquivo. Defina data.baseUrl como o URL da sua instância do Ops Manager em status.opsManager.url.

Exemplo:

apiVersion: v1
kind: ConfigMap
metadata:
  name: my-project
  namespace: mongodb
data:
  baseUrl: http://ops-manager-svc.mongodb.svc.cluster.local:8080
  projectName: my-project
  orgId: <your-org-id>

Substitua <your-org-id> pelo ID da organização do Ops Manager. Você pode encontrar esse valor na URL da IU do Ops Manager: http://<ops-manager-url>/v2#/org/<orgId>/projects.

Para saber mais, consulte as descrições do parâmetro.

Crie e salve o segredo.

Se você gerou o Segredo na IU do Ops Manager, copie e salve o arquivo secret.yaml gerado. Caso contrário, crie um segredo que contenha as chaves da API para sua organização do Ops Manager.

Exemplo:

apiVersion: v1
kind: Secret
metadata:
  name: organization-secret
  namespace: mongodb
stringData:
  publicKey: <public_key>
  privateKey: <private_key>

Para criar chaves de API programáticas, consulte Criar credenciais para o operador do Kubernetes.

Aplique o ConfigMap e Secreto.

Execute o seguinte comando:

kubectl apply -f secret.yaml -f config-map.yaml

Implemente o recurso conjunto de réplicas MongoDB.

Copie e salve o seguinte arquivo YAML:

apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: demo-mongodb-cluster-1
  namespace: mongodb
spec:
  members: 3
  version: 8.0.0
  type: ReplicaSet
  security:
    authentication:
      enabled: true
      modes: ["SCRAM"]
  opsManager:
    configMapRef:
      name: my-project
  credentials: organization-secret
  persistent: true
  podSpec:
    podTemplate:
      spec:
       containers:
        - name: mongodb-enterprise-database
          resources:
            limits:
              cpu: 2
              memory: 1.5G
            requests:
              cpu: 1
              memory: 1G
            persistence:
              single:
                storage: 10Gi

Execute o seguinte comando:
kubectl apply -f <replica-set-conf>.yaml

Crie um segredo com sua senha de usuário de banco de dados.

Escolha uma senha para o usuário de banco de dados MongoDB e armazene-a em um segredo. Esta senha pode ser qualquer valor que você escolher. Você faz referência a este segredo ao criar o usuário do banco de dados na próxima etapa.

Você pode armazenar a senha como texto simples (usando stringData) ou como um valor codificado em Base64(usando data).

Para obter uma senha de texto não criptografado, crie e salve o seguinte arquivo YAML:

apiVersion: v1
kind: Secret
metadata:
  name: mms-user-1-password
  # corresponds to user.spec.passwordSecretKeyRef.name
type: Opaque
stringData:
  password: <my-plain-text-password>
  # corresponds to user.spec.passwordSecretKeyRef.key

Para obter uma senha codificada em Base64, crie e salve o seguinte arquivo YAML:

apiVersion: v1
kind: Secret
metadata:
  name: mms-user-1-password
  # corresponds to user.spec.passwordSecretKeyRef.name
type: Opaque
data:
  password: <base-64-encoded-password>
  # corresponds to user.spec.passwordSecretKeyRef.key

Substitua o placeholder pela senha escolhida. Para saber mais, consulte Gerenciar usuários de banco de dados usando a autenticação SCRAM.

Criar um utilizador de banco de dados.

Copie e salve o seguinte arquivo de Especificação de recursos do usuário do MongoDB:

apiVersion: mongodb.com/v1
kind: MongoDBUser
metadata:
  name: mms-scram-user-1
spec:
  passwordSecretKeyRef:
    name: mms-user-1-password
    # Match to metadata.name of the User Secret
    key: password
  username: "mms-scram-user-1"
  db: "admin" #
  mongodbResourceRef:
    name: "demo-mongodb-cluster-1"
    # Match to MongoDB resource using authentication
  roles:
  - db: "admin"
    name: "clusterAdmin"
  - db: "admin"
    name: "userAdminAnyDatabase"
  - db: "admin"
    name: "readWrite"

Execute o seguinte comando:
kubectl apply -f <database-user-conf>.yaml

Opcional: visualize o usuário recém-criado no Cloud Manager ou no Ops Manager.

Você pode visualizar o usuário recém-criado no Cloud Manager ou Ops Manager:

Na visualização Deployment do projeto, clique na guia Security.
Clique no separador MongoDB Users aninhado.

Conecte-se ao conjunto de réplicas do MongoDB.

Execute as seguintes etapas no aplicativo MongoDB Ops Manager:

Clique em Deployment na navegação à esquerda.
Clique em para o sistema ao qual você deseja se conectar.
Clique em Connect to this instance.
Execute o comando de conexão em um terminal para se conectar ao sistema.

Tutoriais do OpenShift