Para agentes de IA: hay un índice de documentación disponible en https://www.mongodb.com/es/docs/llms.txt — versiones en markdown de todas las páginas están disponibles agregando .md a cualquier ruta URL.
Docs Menu
Docs Home
/ /
Atlas Access
Docs Home
/
Gestión
/
Operador de Atlas Kubernetes
/
Atlas Access
Docs Home
/
Gestión
/
Operador de Atlas Kubernetes
/
Atlas Access

Configure el almacenamiento de secretos

Puede elegir dónde almacenar información confidencial para los componentes que Atlas Kubernetes Operator gestiona, pero Atlas Kubernetes Operator debe encontrar los secretos de Kubernetes que espera. Puedes almacenar secretos para Atlas Kubernetes Operator de muchas maneras, incluidos los siguientes métodos:

  • Coloca información sensible directamente en secretos de Kubernetes secrets. Todos los tutoriales en la documentación del Atlas Kubernetes Operator utilizan secreto de Kubernetes por defecto. Para usar secretos de Kubernetes, sigue los pasos de los tutoriales.

  • Colocar información confidencial en un repositorio de Github siguiendo un flujo GitOps. Para almacenar los datos confidenciales de git de manera segura, puedes utilizar herramientas como Sealed Secrets, que cifra los secretos para el clúster de destino previsto.

  • Coloque información confidencial en una herramienta externa de almacenamiento de secretos, como HashiCorp Vault o soluciones nativas de gestión de secretos de Hyperscalers. Una herramienta intermediaria de aprovisionamiento secreto obtiene información confidencial del almacenamiento externo de secretos y crea secretos de Kubernetes a partir de la información confidencial. Para obtener más información sobre la herramienta de provisionamineto secreto, consulta Consideraciones.

Este tutorial configura una herramienta externa de almacenamiento de secretos para usar con Atlas Kubernetes Operator. Este tutorial se centra en configuraciones "sin secretos" que no requieren que el Atlas Kubernetes Operator cree y almacene un secreto para aprovisionar secretos en su clúster de Kubernetes.

Considerations

El siguiente tutorial instala o configura las siguientes herramientas y opciones:

  • Una herramienta de provisionamineto secreta. La herramienta de aprovisionamiento de secretos utiliza uno o más mecanismos de autenticación para recuperar las credenciales del servicio de gestión de secretos y crear secretos que el Atlas Kubernetes Operator puede utilizar. Este tutorial instala una de las siguientes herramientas de provisionamineto de secretos de código abierto:

  • Autenticación para acceder a los secretos. Puedes usar diferentes métodos para autenticar las cuentas de servicio y los espacios de nombres que pueden acceder a secretos en HashiCorp Vault:

    Alternativamente, el KMS de tu proveedor de nube puede usar sistemas nativos de IAM para proporcionar esta autenticación, lo cual no se aborda en este tutorial. Para aprender a configurar el KMS de tu proveedor de nube para la autenticación, consulta los siguientes recursos en la documentación de External Secrets Operator:

Requisitos previos

Antes de completar este tutorial, necesita las siguientes herramientas y configuraciones:

  • Cuentas de servicio en ejecución para Kubernetes, Atlas Kubernetes Operator y Atlas y privilegios suficientes para configurarlas.

    Necesitas un clúster de Kubernetes en ejecución con nodos que usen procesadores de la arquitectura x86-64, AMD64 o ARM64. Para este tutorial, el clúster de Kubernetes es https://kube01.internal.io y escucha en el puerto por defecto (443).

    Puedes acceder al proyecto Atlas Kubernetes Operator en GitHub:

    Para instalar el operador Atlas Kubernetes utilizando Atlas CLI, ejecuta el siguiente comando:

    atlas kubernetes operator install [options]

    Para obtener más información sobre la sintaxis del comando y los parámetros, consulta la documentación de Atlas CLI para atlas kubernetes operator install.

    Tip

    Consulte: Enlaces relacionados

    Para implementar el Atlas Kubernetes Operator, ejecuta el siguiente comando. Sustituye <version> por el número de versiónmás reciente.

    kubectl apply -f https://raw.githubusercontent.com/mongodb/mongodb-atlas-kubernetes/<version>/deploy/all-in-one.yaml

    Para registrarte en un cuenta de Atlas, consulta Crea una cuenta de Atlas.

  • Claves API. Debe crear una clave de API y configurar el API Access List.

    Necesita la siguiente llave pública de API, llave privada de API y la información del Identificador de la Organización para configurar el acceso de Atlas Kubernetes Operator a Atlas.

  • Una bóveda de almacenamiento secreta. Este tutorial utiliza HashiCorp Vault, que es un servicio externo para el almacenamiento de secretos, ejecutándose en https://vault.internal.io.

    Puedes usar otros almacenes de almacenamiento secreto con Atlas Kubernetes Operator según sea necesario, incluido el Cloud KMS de AWS, Azure y Google.

  • Solo acceso interno. Para evitar exponer información confidencial a través de Internet público, los siguientes componentes de la solución de almacenamiento de secretos permiten solo acceso interno:

    • El HashiCorp Vault o servicio KMS.

    • El servicio de APIs de clúster de Kubernetes.

    • La red interna. Este tutorial usa internal.io.

    Mientras que los componentes anteriores solo permiten el acceso interno, permiten el acceso entre sí y permiten el acceso a cualquier persona dentro de tu equipo u organización. Esta es una de las mejores prácticas para la seguridad.

  • Autoridades certificadoras (AC) públicas. Puedes utilizar autoridades de certificación públicas para evitar gestionar y distribuir certificados raíz de autoridades de certificación personalizados.

    Puede automatizar la gestión y renovación de los certificados CA utilizando cualquiera de las siguientes herramientas:

    En este tutorial:

    • Todos los internal.io servicios HTTPs son direcciones internas, pero sus sitios HTTPS presentan certificados firmados por una Autoridad Certificadora (CA) pública, renovados automáticamente.

    • No se requiere TLS mutuo (mTLS) para esta integración porque solo realiza la validación HTTPS del lado del servidor.

    • Los clientes pueden confiar en estos certificados de servicio sin provisionamiento extra de certificados.

Procedimiento

Siga estos pasos para configurar el almacenamiento de secretos para Atlas Kubernetes Operator.

1

Instalar la herramienta secreta de provisionamineto en el clúster objetivo.

Seleccione una herramienta secreta de provisionamineto para instalarla.

Para usar External Secrets operador como herramienta de provisionamineto de secretos:

  1. Ejecute los siguientes comandos para instalar External Secrets Operator con Helm Charts e iniciar el servicio:

    helm repo add external-secrets https://charts.external-secrets.io
    helm upgrade -i --atomic \
    -n external-secrets --create-namespace --set extraArgs.loglevel=debug \
    external-secrets external-secrets/external-secrets`

  2. Asegúrese de que External Secrets se ejecute correctamente:

    kubectl get pod -n external-secrets -l app.kubernetes.io/name=external-secrets
    NAME                                READY   STATUS    RESTARTS   AGE
    external-secrets-5779d5d6f6-2lhgd   1/1     Running   0          70s
2

Configura la autenticación para acceder a los secretos.

Para configurar la autenticación OIDC, JWT y Kubernetes:

  1. Ejecuta el siguiente comando para habilitar la autenticación OIDC JWT para la ruta de montaje. Si configura varios clústeres de Kubernetes, debe habilitar la autenticación OIDC JWT para la ruta de montaje de cada clúster.

    vault auth enable -path=jwt-kube01 jwt

  2. Ejecute el siguiente comando para permitir el acceso no autenticado a las URL de descubrimiento de OIDC en el clúster kube01.internal.io:

    $ kubectl create clusterrolebinding oidc-reviewer  \
      --clusterrole=system:service-account-issuer-discovery \
      --group=system:unauthenticated

  3. Ejecute el siguiente comando para indicar a HashiCorp Vault que confíe en el clúster. El emisor del clúster en https://kube01.internal.io/ debe coincidir con la URL del documento de descubrimiento de OIDC en .well-known/openid-configuration.

    curl https://kube01.internal.io/.well-known/openid-configuration | jq .issuer
    https://kube01.internal.io/
    vault write auth/jwt-kube01/config jwks_url="https://kube01.internal.io/openid/v1/jwks"

  4. Crea las directivas que permiten el acceso a los secretos que deseas exponer al clúster.

    El siguiente ejemplo crea la política external-secrets que se especifica en pasos posteriores.

    echo external-secrets-policy.hcl
    path "secret/data/kube01/external-secrets/*" {
      capabilities = ["read"]
    }

  5. Ejecuta el comando para crear un rol de HashiCorp Vault y enlazar una cuenta de servicio de Kubernetes a este rol, lo que restringe el acceso de la cuenta de servicio dentro del HashiCorp Vault.

    El siguiente comando crea el rol jwt-kube01-system del tipo JWT (OIDC) para la audiencia vault. El comando especifica la reclamación de usuario sub y la cuenta de servicio Kubernetes default en el namespace mongodb-atlas-system como el sujeto vinculado. Este comando vincula el rol al conjunto de permisos de la política external-secrets dentro de HashiCorp Vault.

    vault write auth/jwt-kube01/role/jwt-kube01-system role_type="jwt" bound_audiences=vault \
      user_claim="sub" bound_subject="system:serviceaccount:mongodb-atlas-system:default" \
      policies="external-secrets"

  6. Ejecute el comando para crear otro rol para que el External Secrets Operator acceda al namespace default.

    El siguiente comando crea el rol jwt-kube01-default de tipo JWT (OIDC) para el público vault. Este comando especifica la declaración de usuario sub, y la cuenta de servicio de Kubernetes default en el namespace default como el sujeto vinculado. Este comando vincula el rol al conjunto de permisos de la política external-secrets dentro de HashiCorp Vault.

    vault write auth/jwt-kube01/role/jwt-kube01-default role_type="jwt" bound_audiences=vault \
      user_claim="sub" bound_subject="system:serviceaccount:default:default" \
      policies="external-secrets"

  7. Asegúrate de que la autenticación OIDC se ejecute correctamente para la cuenta de servicio del sistema:

    export TEST_JWT_TOKEN=$(kubectl -n mongodb-atlas-system create token default --audience "vault")
    vault write auth/jwt-kube01/login role=jwt-kube01-system jwt=$(TEST_JWT_TOKEN)

    Atlas Kubernetes Operator devuelve las credenciales OIDC JWT de la cuenta de servicio del sistema.

  8. Asegúrese de que la autenticación OIDC se ejecute correctamente para la cuenta de servicio por defecto:

    export TEST_JWT_TOKEN=$(kubectl -n default create token default --audience "vault")
    vault write auth/jwt-kube01/login role=jwt-kube01-default jwt=$(TEST_JWT_TOKEN)

    Atlas Kubernetes Operator devuelve tus credenciales OIDC JWT para la cuenta de servicio por defecto.

3

Configura el provisionamineto automático de secretos.

Para aprovisionar secretos con External Secrets Operator:

Tip

El siguiente ejemplo muestra las propiedades de la clave API (publicApiKey, privateApiKey). Si utiliza cuentas de servicio, reemplácelas por clientId y clientSecret. Para obtener más información, consulte Configurar el acceso a Atlas mediante cuentas de servicio.

  1. Implementa el recurso personalizado SecretStore para la cuenta de servicio default en el espacio de nombres mongodb-atlas-system:

    $ cat external-secrets/vault-system.yaml
    apiVersion: external-secrets.io/v1beta1
    kind: SecretStore
    metadata:
      name: vault-store
      namespace: mongodb-atlas-system
    spec:
      provider:
        vault:
          server: "https://vault.internal.io"
          path: "secret"
          version: "v2"
          auth:
            jwt:
              path: "jwt-kube01"
              role: "jwt-kube01-system"
              kubernetesServiceAccountToken:
                expirationSeconds: 600
                serviceAccountRef:
                  name: "default"
                  audiences:
                  - vault
    $ kubectl apply -f external-secrets/vault-system.yaml

  2. Implementa el recurso personalizado SecretStore para la cuenta de servicio default en el espacio de nombres default:

    $ cat external-secrets/vault-default.yaml
    apiVersion: external-secrets.io/v1beta1
    kind: SecretStore
    metadata:
      name: vault-store
      namespace: default
    spec:
      provider:
        vault:
          server: "https://vault.internal.io"
          path: "secret"
          version: "v2"
          auth:
            jwt:
              path: "jwt-kube01"
              role: "jwt-role"
              kubernetesServiceAccountToken:
                expirationSeconds: 600
                serviceAccountRef:
                  name: "default"
                  audiences:
                  - vault
    $ kubectl apply -f external-secrets/vault-default.yaml

  3. Despliegue el recurso personalizado ExternalSecret que hace referencia al secreto que contiene la clave API. Debe establecer spec.target.template.metadata.labels en atlas.mongodb.com/type con el valor credentials para que Atlas Kubernetes Operator pueda hallar el secreto que crea External Secrets operador.

    Antes de ejecutar el siguiente comando, asegúrese de que HashiCorp Vault tenga el secreto poblado en la ruta Kv V2 secret/data/kube01/external-secrets/atlas-account con las siguientes propiedades:

    • orgId

    • publicApiKey

    • privateApiKey

    $ cat external-secrets/atlas.yaml
    apiVersion: external-secrets.io/v1beta1
    kind: ExternalSecret
    metadata:
      name: atlas
      namespace: mongodb-atlas-system
    spec:
        refreshInterval: "15s"
        secretStoreRef:
          name: vault-store
          kind: SecretStore
        target:
          name: mongodb-atlas-operator-api-key
          template:
            metadata:
              labels:
                atlas.mongodb.com/type: credentials
        data:
        - secretKey: orgId
          remoteRef:
            key: secret/data/kube01/external-secrets/atlas-account
            property: orgId
        - secretKey: publicApiKey
          remoteRef:
            key: secret/data/kube01/external-secrets/atlas-account
            property: publicApiKey
        - secretKey: privateApiKey
          remoteRef:
            key: secret/data/kube01/external-secrets/atlas-account
            property: privateApiKey
      $ kubectl apply -f external-secrets/atlas.yaml

    Este comando crea el secreto mongodb-atlas-operator-api-key de Kubernetes en el namespace mongodb-atlas-system.

  4. Implemente el recurso personalizado ExternalSecret que referencia el secreto que contiene las credenciales de usuario de base de datos. Debes configurar spec.target.template.metadata.labels en atlas.mongodb.com/type con el valor credentials para que el Atlas Kubernetes Operator pueda encontrar el secreto que crea el External Secrets Operator.

    Antes de ejecutar el siguiente comando, asegura que HashiCorp Vault tiene el secreto poblado en la ruta Kv V2 secret/data/kube01/external-secrets/db-user con la propiedad password.

    $ cat external-secrets/dbuser.yaml
    apiVersion: external-secrets.io/v1beta1
    kind: ExternalSecret
    metadata:
      name: dbuser
      namespace: default
    spec:
        refreshInterval: "15s"
        secretStoreRef:
          name: vault-store
          kind: SecretStore
        target:
          name: dbuser-password
          template:
            metadata:
              labels:
                atlas.mongodb.com/type: credentials
        data:
        - secretKey: password
          remoteRef:
            key: secret/data/kube01/external-secrets/db-user
            property: password
      $ kubectl apply -f external-secrets/atlas.yaml

  5. Asegúrate de que los secretos se devuelvan como se espera cuando ejecutes los siguientes comandos:

    $ kubectl get -n mongodb-atlas-system secrets/mongodb-atlas-operator-api-key
    $ kubectl get -n default secrets/dbuser-password
4

Implemente recursos personalizados del Atlas Kubernetes Operator.

Ahora puede implementar recursos personalizados de Atlas Kubernetes Operator. Atlas Kubernetes Operator se autentica con el secreto de Kubernetes que hacen referencia a su HashiCorp Vault. Ajusta los valores timeout según sea necesario para tus implementaciones.

kubectl apply -f ako/project.yaml
kubectl apply -f ako/deployment.yaml
kubectl apply -f ako/user.yaml
kubectl wait --for=condition=ready atlasdeployment/serverless-deployment --timeout=10m
kubectl wait --for=condition=ready atlasdatabaseuser/user --timeout=10m

Para obtener más información sobre estos recursos personalizados, consulta Recursos personalizados.

5

Prueba tu implementación del Atlas Kubernetes Operator.

Para probar tu implementación del Atlas Kubernetes Operator, ejecuta el siguiente comando:

export ATLAS_DEPLOYMENT_CONN_STR=$(kubectl get secrets/test-atlas-operator-project-test-serverless-deployment-dbuser -o jsonpath='{.data.connectionStringStandardSrv}' |base64 -d)
mongosh $(ATLAS_DEPLOYMENT_CONN_STR) --apiVersion 1 --eval "show dbs"

Atlas Kubernetes Operator devuelve una lista de tus implementaciones de la base de datos.

Volver
Atlas Access
Next
Emparejamiento de red
Califique esta página

En esta página