IBM Cloud Docs
Segredos seguros para aplicativos executados no cluster Kubernetes

Segredos seguros para aplicativos executados no cluster Kubernetes

Neste tutorial, você aprende como usar IBM Cloud® Secrets Manager para gerenciar segredos para aplicativos que executam seu cluster IBM Cloud Kubernetes Service usando a ferramenta de código aberto Segredos Externos.

Alternativamente, você pode usar o plug-in CLI Kubernetes Service para gerenciar os segredos TLS e não TLS. Para saber mais sobre essa abordagem, consulte Configurando o Kubernetes Ingress.

Você é desenvolvedor em uma organização e sua equipe está usando o Kubernetes Service para implantar aplicativos e serviços em contêineres no IBM Cloud. Em seu fluxo atual, você usa o Kubernetes Secrets para armazenar os dados confidenciais, como senhas e chaves de API, que são usados pelos aplicativos e serviços executados em seu cluster. Para ter mais controle sobre os segredos de seu aplicativo, você deseja a capacidade de armazenar seus segredos de cluster em um serviço de gerenciamento de segredos externo, em que seja possível criptografá-los em repouso, monitorar sua atividade e gerenciá-los facilmente.

Com o Secrets Manager, é possível centralizar e proteger os segredos que são usados pelos apps que são executados em seus clusters Kubernetes. Em vez de injetar seus segredos no tempo de implementação, é possível configurar seus apps para recuperar de forma segura os segredos do Secrets Manager no tempo de execução. Quando é hora de girar o segredo, é possível fazer isso a partir do Secrets Manager. Por exemplo, considere o seguinte cenário:

O diagrama mostra o fluxo básico entre Secrets Manager e seu cluster Kubernetes.
External Secrets flow

  1. Como desenvolvedor, você usa o Secrets Manager para armazenar um segredo para um aplicativo que deseja implementar em um cluster Kubernetes.
  2. O Secrets Manager fornece um ID para o segredo. Você inclui o ID no arquivo de configuração ExternalSecrets para o seu app e aplica a configuração ao cluster.
  3. O controlador do External Secrets busca os objetos do ExternalSecrets no arquivo de configuração que você definiu usando a API do Kubernetes.
  4. No tempo de execução do aplicativo, o controlador recupera os dados de segredo do Secrets Manager e converte os objetos do ExternalSecrets em segredos do Kubernetes para o seu cluster.

Este cenário apresenta uma ferramenta de terceiros que pode afetar a prontidão de conformidade das cargas de trabalho executadas em seu cluster Kubernetes. Se você adicionar uma comunidade ou ferramenta de terceiros, lembre-se de que você é responsável por manter a conformidade de seus aplicativos e trabalhar com o provedor apropriado para solucionar quaisquer problemas. Para obter mais informações, consulte Suas responsabilidades com o uso do IBM Cloud Kubernetes Service.

Antes de Iniciar

Antes de começar, certifique-se de ter acesso à plataforma de Administrador para que seja possível criar credenciais de conta e provisionar recursos. Também serão necessários os pré-requisitos a seguir:

Configure seu ambiente

Para trabalhar com o Secrets Manager e o Kubernetes Service, é necessário criar um cluster e uma instância do Secrets Manager em sua conta do IBM Cloud. Também é necessário configurar permissões para que seja possível executar operações em ambos os serviços.

Nesta etapa, você configura um ambiente de acesso, criando um ID de serviço e uma chave de API do IBM Cloud. No final do tutorial, será possível remover facilmente seus recursos se não precisar mais deles. Alternativamente, você pode usar um perfil confiável para autorizar o operador de Secrets Externos.

Crie um ID de serviço e chave de API

Comece criando as credenciais da conta necessárias para poder executar operações com relação ao Secrets Manager e ao Kubernetes Service.

  1. Na linha de comandos, efetue login no IBM Cloud por meio da CLI do IBM Cloud.

    ibmcloud login
    

    Se o login falhar, execute o comando ibmcloud login --sso para tentar novamente. O parâmetro --sso é necessário quando você efetua login com um ID federado. Se essa opção for usada, acesse o link listado na saída da CLI para gerar uma senha descartável.

  2. Crie um ID de serviço e configure-o como uma variável de ambiente.

    export SERVICE_ID=`ibmcloud iam service-id-create kubernetes-secrets-tutorial --description "A service ID for testing ESO integration" --output json | jq -r ".id"`; echo $SERVICE_ID
    
  3. Designe as permissões de ID do serviço para ler segredos do Secrets Manager.

    ibmcloud iam service-policy-create $SERVICE_ID --roles "SecretsReader" --service-name secrets-manager
    

    Ao atribuir acesso ao serviço SecretsReader, o controlador External Secrets tem o nível correto de acesso para ler segredos do Secrets Manager preenchê-los em um cluster Kubernetes.

  4. Crie uma chave de API IBM Cloud para o seu ID de serviço.

    export IBM_CLOUD_API_KEY=`ibmcloud iam service-api-key-create kubernetes-secrets-tutorial $SERVICE_ID --description "An API key for testing ESO integration." --output json | jq -r ".apikey"`
    

    Essa chave de API será usada posteriormente para configurar o Secrets Manager para a sua implementação de cluster.

Crie um cluster Kubernetes e uma instância do Secrets Manager

Crie um cluster Kubernetes e uma instância de Secrets Manager em sua conta IBM Cloud.

É possível criar um cluster Kubernetes e uma instância de serviço do Secrets Manager gratuitamente por conta do IBM Cloud. Se você já possuir ambos os recursos em sua conta, será possível usar seu cluster e instância do Secrets Manager gratuitos existentes para concluir o tutorial.

  1. Na linha de comandos, selecione a conta, a região e o grupo de recursos nos quais você deseja criar uma instância de serviço do Secrets Manager.

    Neste tutorial, você interagirá com a região de Dallas. Se estiver conectado a uma região diferente, certifique-se de configurar Dallas como sua região de destino executando o comando a seguir.

    ibmcloud target -r us-south -g default
    
  2. Crie um cluster Kubernetes.

    ibmcloud ks cluster create classic --zone dal10 --flavor free --name my-test-cluster
    
  3. Crie uma instância do Secrets Manager.

    ibmcloud resource service-instance-create my-secrets-manager secrets-manager trial us-south
    

    O fornecimento para o Secrets Manager e seu cluster de Kubernetes leva de 5 a 15 minutos para ser concluído.

  4. Antes de prosseguir para a próxima etapa, verifique se o cluster e a instância do Secrets Manager foram provisionados com êxito.

    1. Verifique se a implementação do seu nó do trabalhador foi concluída.

      ibmcloud ks worker ls --cluster my-test-cluster
      

      Quando o nó de trabalho conclui o provisionamento, o status muda para Pronto.

      ID                                                       Public IP       Private IP      Flavor   State          Status                Zone    Version
      kube-c39pf4ld0m87o3fv1utg-mytestclust-default-000000dd   169.xx.xx.xxx   10.xxx.xx.xxx   free     normal   Ready   mex01   1.20.7_1543
      
    2. Em seguida, verifique se sua instância do Secrets Manager foi provisionada com sucesso.

      ibmcloud resource service-instance my-secrets-manager
      

      Quando o provisionamento da instância termina, o estado muda para Ativo.

      Name:                  my-secrets-manager
      ID:                    crn:v1:bluemix:public:secrets-manager:us-south:a/f047b55a3362ac06afad8a3f2f5586ea:fe06948b-0c6b-4183-8d4b-e6c1d38ff65f::
      GUID:                  fe06948b-0c6b-4183-8d4b-e6c1d38ff65f
      Location:              us-south
      Service Name:          secrets-manager
      Service Plan Name:     trial
      Resource Group Name:   default
      State:                 active
      Type:                  service_instance
      Sub Type:
      Created at:            2021-01-06T17:11:32Z
      Created by:            zara@example.com
      Updated at:            2021-03-31T02:33:26Z
      
  5. Configure o contexto para seu cluster Kubernetes na CLI.

    ibmcloud ks cluster config --cluster my-test-cluster
    
  6. Verifique se os comandos do kubectl são executados adequadamente e se o contexto do Kubernetes está configurado para o seu cluster.

    kubectl config current-context
    

    Saída de exemplo:

    my-test-cluster/<your_cluster_ID>
    

Crie um perfil confiável.

Um perfil confiável possibilita que o operador de Secrets Externos leia a partir de Secrets Manager, sem ter que criar um ID de serviço ou gerenciar uma chave API.

  1. Obtem os CRNs para sua instância Secrets Manager e Kubernetes.

    CLUSTER_CRN=$(ibmcloud ks cluster get --cluster my-test-cluster --output json | jq -r '.crn')
    SECRETS_MANAGER_CRN=$(ibmcloud resource service-instance my-secrets-manager --output JSON | jq -r '.[0].crn')
    
  2. Crie o perfil.

    ibmcloud iam trusted-profile-create 'External Secrets'
    
  3. Autorize o cluster Kubernetes a utilizar o perfil confiável.

    Kubernetes

    ibmcloud iam trusted-profile-rule-create 'External Secrets' --name kubernetes --type Profile-CR --conditions claim:namespace,operator:EQUALS,value:external-secrets --conditions claim:name,operator:EQUALS,value:external-secrets --conditions claim:crn,operator:EQUALS,value:$CLUSTER_CRN --cr-type IKS_SA
    

    OpenShift

    ibmcloud iam trusted-profile-rule-create 'External Secrets' --name kubernetes --type Profile-CR --conditions claim:namespace,operator:EQUALS,value:external-secrets-operator --conditions claim:name,operator:EQUALS,value:cluster-external-secrets --conditions claim:crn,operator:EQUALS,value:$CLUSTER_CRN --cr-type IKS_SA
    
  4. Crie uma política de acesso que permita que o perfil confiável leia segredos de sua instância Secrets Manager.

    ibmcloud iam trusted-profile-policy-create 'External Secrets' --roles SecretsReader --service-instance $SECRETS_MANAGER_CRN --service-name secrets-manager
    

Prepare sua instância do Secrets Manager

Por fim, configure sua instância do Secrets Manager para começar a trabalhar com segredos.

  1. Na linha de comandos, verifique se é possível acessar o plug-in da CLI do Secrets Manager.

    ibmcloud secrets-manager --help
    

    Ainda não tem o plug-in? Para instalar o plug-in da CLI do Secrets Manager, execute ibmcloud plugin install secrets-manager.

  2. Exporte uma variável de ambiente com sua URL de terminal de API do Secrets Manager exclusiva.

    export SECRETS_MANAGER_URL=`ibmcloud resource service-instance my-secrets-manager --output json | jq -r '.[].dashboard_url | .[0:-3]'`; echo $SECRETS_MANAGER_URL
    
  3. Crie um grupo de segredos para sua instância.

    Grupos de segredos são uma forma de organizar e controlar quem em sua equipe tem acesso a segredos específicos em sua instância. Para criar um grupo de segredos a partir da CLI do IBM Cloud, use o comando ibmcloud secrets-manager secret-group-create. Execute o comando a seguir para criar um grupo de segredos e para armazenar seu ID como uma variável de ambiente.

    export SECRET_GROUP_ID=`ibmcloud secrets-manager secret-group-create --name my-test-secret-group --description "Read and write to my test app" --output json --service-url $SECRETS_MANAGER_URL | jq -r '.id'`; echo $SECRET_GROUP_ID
    

    Usando um prompt de comandos do Windows™ (cmd.exe) ou PowerShell? Se você encontrar erros ao transmitir conteúdo JSON na linha de comandos, poderá ser necessário ajustar as sequências para os requisitos de escape de aspas específicos de seu sistema operacional. Para obter mais informações, consulte Usando aspas com sequências de caracteres na CLI do IBM Cloud.

    Sucesso! Agora é possível armazenar o segredo no Secrets Manager que você deseja preencher em seu cluster Kubernetes. Continue com a próxima etapa.

Crie um segredo no Secrets Manager

Os segredos são específicos do aplicativo e podem variar de acordo com o aplicativo ou serviço individual que os requer. Um segredo pode consistir em um nome de usuário, senha, chave de API ou qualquer outro tipo de credencial.

O Secrets Manager suporta vários tipos de segredos que você pode criar e gerenciar no serviço. Por exemplo, se você precisar gerenciar uma chave de API para um app que é protegido pela autenticação IAM do IBM Cloud, será possível criar uma Credencial do IAM. Ou, se precisar gerenciar um segredo que pode conter qualquer tipo de dados estruturados ou não estruturados, é possível criar um segredo arbitrário.

Neste tutorial, você cria um nome de usuário e senha como exemplo. Para criar um segredo a partir da CLI do IBM Cloud, use o comando ibmcloud secrets-manager secret-create. Execute o comando a seguir para criar o segredo e armazene seu ID como uma variável de ambiente.

export SECRET_ID=`ibmcloud secrets-manager secret-create --secret-type=username_password --secret-name example_username_password --username-password-username user123 --username-password-password cloudy-rainy-coffee-book --secret-labels "my-test-cluster, tutorial" --secret-group-id $SECRET_GROUP_ID --output json $SECRETS_MANAGER_URL | jq -r '.id'`; echo $SECRET_ID

Certifique-se de atualizar instance_id e region para o seu.

A saída mostra o ID do seu segredo recém-criado. Por exemplo:

e0246cea-d668-aba7-eef2-58ca11ad3707

Configurar o External Secrets Operator

Agora que você tem um segredo para seu aplicativo, pode configurar a ferramenta External Secrets Operator para seu cluster. Este pacote configura a conexão entre o Secrets Manager e seu cluster criando objetos do ExternalSecrets que são convertidos em segredos do Kubernetes para o seu aplicativo.

External Secrets Operator é uma ferramenta de software livre que não é mantida pela IBM. Para obter mais informações sobre essa ferramenta ou para solucionar problemas, consulte a documentação do projeto.

Configure External Secrets Operator para seu cluster

Kubernetes

Primeiro, inclua recursos do external-secrets em seu cluster instalando o Gráfico do Helm oficial. Para obter mais opções de instalação, confira o guia de introdução.

  1. Execute o comando a seguir para instalar o repositório Helm do External Secrets Operator:

    helm repo add external-secrets https://charts.external-secrets.io
    
  2. Configure a autenticação entre o External Secrets Operator e o Secrets Manager.

    Se você está usando um ID de serviço para autenticar:

    kubectl -n default create secret generic secret-api-key --from-literal=apikey=$IBM_CLOUD_API_KEY
    helm install external-secrets external-secrets/external-secrets -n external-secrets --create-namespace --set installCRDs=true
    

    Se você está usando um perfil confiável para autenticar:

    echo '
    installCRDs: true
    extraVolumes:
    - name: sa-token
      projected:
        defaultMode: 420
        sources:
        - serviceAccountToken:
            path: sa-token
            expirationSeconds: 3600
            audience: iam
    extraVolumeMounts:
    - mountPath: /var/run/secrets/tokens
      name: sa-token
    webhook:
      extraVolumes:
      - name: sa-token
        projected:
          defaultMode: 420
          sources:
          - serviceAccountToken:
              path: sa-token
              expirationSeconds: 3600
              audience: iam
      extraVolumeMounts:
      - mountPath: /var/run/secrets/tokens
        name: sa-token' >values.yml
    helm install external-secrets external-secrets/external-secrets -n external-secrets --create-namespace -f values.yml
    

OpenShift

  1. Instale o External Secrets Operator criando os seguintes recursos:

    echo '
    apiVersion: v1
    kind: Namespace
    metadata:
      name: external-secrets-operator
    ---
    apiVersion: operators.coreos.com/v1
    kind: OperatorGroup
    metadata:
      name: external-secrets-operator
      namespace: external-secrets-operator
    spec:
      targetNamespaces:
        - external-secrets-operator
    ---
    apiVersion: operators.coreos.com/v1alpha1
    kind: Subscription
    metadata:
      name: external-secrets-operator
      namespace: external-secrets-operator
    spec:
      channel: stable
      installPlanApproval: Automatic
      name: external-secrets-operator
      source: community-operators
      sourceNamespace: openshift-marketplace
    ' | oc create -f-
    
  2. Configure a autenticação entre o External Secrets Operator e o Secrets Manager.

    Se você está usando um ID de serviço para autenticar:

    echo "
    apiVersion: operator.external-secrets.io/v1alpha1
    kind: OperatorConfig
    metadata:
      name: cluster
      namespace: external-secrets-operator
    spec: {}
    ---
    apiVersion: v1
    kind: Secret
    metadata:
      name: secret-api-key
      namespace: default
    type: Opaque
    stringData:
      apikey: $IBM_CLOUD_API_KEY
    " | oc create -f-
    

    Se você está usando um perfil confiável para autenticar:

    echo '
    apiVersion: operator.external-secrets.io/v1alpha1
    kind: OperatorConfig
    metadata:
      name: cluster
      namespace: external-secrets-operator
    spec:
      extraVolumeMounts:
      - mountPath: /var/run/secrets/tokens
        name: sa-token
      extraVolumes:
      - name: sa-token
        projected:
          defaultMode: 420
          sources:
          - serviceAccountToken:
              audience: iam
              expirationSeconds: 3600
              path: sa-token
      webhook:
        extraVolumeMounts:
        - mountPath: /var/run/secrets/tokens
          name: sa-token
        extraVolumes:
        - name: sa-token
          projected:
            defaultMode: 420
            sources:
            - serviceAccountToken:
                audience: iam
                expirationSeconds: 3600
                path: sa-token
    ' | oc create -f-
    

Atualize sua configuração do aplicativo

Depois de instalar o External Secrets Operator em seu cluster, é possível definir o Secrets Manager como o back-end de segredos para seu aplicativo. Comece criando um arquivo de configuração que tenha como destino o segredo no Secrets Manager que você deseja usar.

  1. No diretório raiz do seu aplicativo, crie um arquivo external-secrets-example.yml.

    touch external-secrets-example.yml
    
  2. Modifique o arquivo para incluir informações sobre o segredo que você deseja buscar a partir de sua instância do Secrets Manager.

    apiVersion: external-secrets.io/v1beta1
    kind: SecretStore
    metadata:
      name: ibmcloud-secrets-manager-example
    spec:
      provider:
        ibm:
          serviceUrl: <endpoint_url>
          auth:
            secretRef:
              secretApiKeySecretRef:
                name: secret-api-key
                key: apikey
    ---
    apiVersion: external-secrets.io/v1beta1
    kind: ExternalSecret
    metadata:
      name: ibmcloud-secrets-manager-example
    spec:
      secretStoreRef:
        name: ibmcloud-secrets-manager-example
        kind: SecretStore
      target:
        name: ibmcloud-secrets-manager-example
      data:
      - secretKey: username
        remoteRef:
          property: username
          key: username_password/<SECRET_ID>
      - secretKey: password
        remoteRef:
          property: password
          key: username_password/<SECRET_ID>
    

    Há dois modos pelos quais você escolhe trabalhar-ID de segredo ou Nome de segredo. Se escolher o nome do segredo, o formato será alterado de secret_type/secret_id para secret_group/secret_type/secret_name.

    Substitua <endpoint_url> pela URL do terminal do Secrets Manager que você recuperou anteriormente. Substitua <SECRET_ID> pelo ID exclusivo do segredo que você criou na etapa anterior.

    Se você estiver usando um perfil confiável para autenticar, substitua o bloco auth pelo trecho a seguir.

          auth:
            containerAuth:
              profile: "External Secrets"
              iamEndpoint: https://iam.cloud.ibm.com
              tokenLocation: /var/run/secrets/tokens/sa-token
    
  3. Aplique a configuração em seu cluster.

    kubectl apply -f external-secrets-example.yml
    
  4. Verifique se o External Secrets Operator consegue buscar o segredo que está armazenado em sua instância do Secrets Manager.

    kubectl get secret ibmcloud-secrets-manager-example -o json | jq '.data | map_values(@base64d)'
    

    Saída de exemplo:

    {
        "password": "cloudy-rainy-coffee-book",
        "username": "user123"
    }
    

    Sucesso! Agora você é capaz de buscar os dados de segredo que estão armazenados em sua instância do Secrets Manager. Continue com a próxima etapa.

Implemente um aplicativo para o cluster

Por fim, é possível implementar um aplicativo em seu cluster que usa o segredo do Secrets Manager que você definiu no arquivo external-secret-example.yml. No tempo de execução do aplicativo, os dados de segredo que são buscados a partir do Secrets Manager são convertidos para um segredo do Kubernetes que pode ser usado pelo seu cluster.

Procurando por exemplos sobre como implementar um app? Confira Implementando Kubernetes-aplicativos nativos em clusters para descobrir mais sobre a implementação de uma única instância de um app.

(Opcional) Limpar recursos

Se os recursos criados neste tutorial não forem mais necessários, será possível concluir as etapas a seguir para removê-los de sua conta.

  1. Exclua seu cluster Kubernetes de teste.

    ibmcloud ks cluster rm --cluster my-test-cluster
    
  2. Exclua sua instância de teste do Secrets Manager.

    ibmcloud resource service-instance-delete my-secrets-manager
    
  3. Exclua sua autorização.

    Se você está usando um ID de serviço.

    ibmcloud iam service-id-delete $SERVICE_ID
    

    Se você está trabalhando com um perfil confiável.

    ibmcloud iam trusted-profile-delete 'External Secrets'
    

Notas de interesse

Ao construir seu documento YAML, lembre-se de que cada chave na seção de dados é pesquisada periodicamente usando REST da instância Secrets Manager. Lembre-se de que:

  1. Por padrão, o intervalo de sondagem é definido como 1 hora e é o valor preferencial a ser definido. Você pode alterar esse valor usando spec.refreshInterval no modelo External Secrets. O intervalo pode ser expresso em unidades de s, m ou h.
  2. Se você configurar o YAML para buscar um segredo do Secrets Manager por nome em vez de ID (keyByName: true), uma chamada adicional será feita pelo ESO para buscar o ID do segredo relevante. Para obter mais informações, consulte a documentação de Segredos externos.

Próximas etapas

Ótimo trabalho! Neste tutorial, você aprendeu como configurar o Secrets Manager para preencher com segurança segredos de aplicativos no seu cluster. Confira mais recursos para ajudá-lo a começar com o Secrets Manager.