Comece a usar o CA Privada da AWS Connector for Kubernetes. - Autoridade de Certificação Privada da AWS
Instalar cert-managerConfigurar permissões do IAMInstalar e configurar o emissor CA Privada da AWS do clusterGerencie o certificado CA Privada da AWS do cliente com o cert-managerEmita seu primeiro certificado TLS

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Comece a usar o CA Privada da AWS Connector for Kubernetes.

Os tópicos a seguir mostram como usar CA Privada da AWS para proteger as comunicações em um cluster Kubernetes. Para outro exemplo, consulte Criptografia em trânsito para Kubernetes ativado. GitHub

Você pode usar uma autoridade de certificação privada para proteger as comunicações com seus clusters do Amazon EKS. Antes de começar, verifique se você tem:

  • Uma AWS conta com permissões apropriadas de acordo com suas políticas de segurança.

    Amazon EKS clusters
    JSON
    JSON
    {
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "IAM",
      "Effect": "Allow",
      "Action": [
        "iam:CreateRole",
        "iam:AttachRolePolicy",
        "iam:GetRole"
      ],
      "Resource": "*"
    },
    {
      "Sid": "EKS",
      "Effect": "Allow",
      "Action": [
        "eks:CreateAddon",
        "eks:DescribeAddon",
        "eks:CreatePodIdentityAssociation",
        "eks:DescribeCluster"
      ],
      "Resource": "*"
    },
    {
      "Sid": "IAMPassRole",
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": "arn:aws:iam::*:role/CertManagerPrivateCARole"
    }
  ]
}
    Other clusters
    JSON
    JSON
    {
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "GetAndIssuePCACertificates",
      "Effect": "Allow",
      "Action": [
        "acm-pca:GetCertificate",
        "acm-pca:IssueCertificate"
      ],
      "Resource": "*"
    },
    {
      "Sid": "RolesAnywhere",
      "Effect": "Allow",
      "Action": [
        "rolesanywhere:CreateProfile"
      ],
      "Resource": "*"
    },
    {
      "Sid": "IAM",
      "Effect": "Allow",
      "Action": [
        "iam:CreateRole",
        "iam:AttachRolePolicy"
      ],
      "Resource": "*"
    },
    {
      "Sid": "IAMPassRole",
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": "arn:aws:iam::*:role/CertManagerPrivateCARole"
    }
  ]
}

  • Um cluster Kubernetes. Para criar um cluster do Amazon Elastic Kubernetes Service, consulte o guia de início rápido do Amazon EKS. Para simplificar, crie uma variável de ambiente para conter o nome do cluster:

    export CLUSTER=aws-privateca-demo

  • O Região da AWS local em que seu cluster CA e Amazon EKS estão localizados. Para simplificar, crie uma variável de ambiente para manter a Região:

    export REGION=aws-region

  • O Amazon Resource Name (ARN) de uma autoridade de certificação CA Privada da AWS privada. Para simplificar, crie uma variável de ambiente para manter o CA ARN privado:

    export CA_ARN="arn:aws:acm-pca:region:account:certificate-authority/CA_ID/certificate/certificate_ID"

    Para criar uma CA privada, consulte https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html Criar uma CA privada no CA Privada da AWS

  • Um computador com o seguinte software instalado:

Instalar cert-manager

Para usar uma CA privada, você deve instalar o cert-manager> complemento que solicita certificados, os distribui e automatiza a renovação do certificado. Você também deve instalar o aws-private-ca-issuer plug-in que permite emitir certificados privados do CA Privada da AWS. Use as etapas a seguir para instalar o complemento e o plug-in.

Amazon EKS clusters

Instale cert-manager como um complemento do Amazon EKS:

aws eks create-addon \
  --cluster-name $CLUSTER \
  --addon-name cert-manager \
  --region $REGION
Other clusters

Instale cert-manager usando o Helm:

helm repo add jetstack https://charts.jetstack.io
helm repo update

helm install cert-manager jetstack/cert-manager \
  --namespace cert-manager \
  --create-namespace \
  --set crds.enabled=true

Configurar permissões do IAM

O aws-privateca-issuer plug-in requer permissão para interagir com CA Privada da AWS. Para clusters do Amazon EKS, você usa a identidade do pod. Para outros clusters que você usa AWS Identity and Access Management Roles Anywhere.

Primeiro, crie uma política do IAM. A política usa a política AWSPrivateCAConnectorForKubernetesPolicy gerenciada. Para obter mais informações sobre a política, consulte o guia AWSPrivateCAConnectorForKubernetesPolicyde referência da política AWS gerenciada.

Amazon EKS clusters

  1. Crie um arquivo chamado trust-policy.json contendo a seguinte política de confiança:

    JSON
    JSON
    {
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "TrustPolicyForEKSClusters",
      "Effect": "Allow",
      "Principal": {
        "Service": "pods.eks.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ]
    }
  ]
}

  2. Execute os comandos a seguir para criar uma função do IAM:

    ROLE_ARN=$(aws iam create-role \
  --role-name CertManagerPrivateCARole \
  --assume-role-policy-document file://trust-policy.json \
  --region $REGION \
  --output text \
  --query "Role.Arn")
 
 aws iam attach-role-policy \
  --role-name CertManagerPrivateCARole \
  --policy-arn arn:aws:iam::aws:policy/AWSPrivateCAConnectorForKubernetesPolicy
Other clusters

  1. Crie uma âncora de confiança que confie na CA privada armazenada em. CA_ARN Para obter instruções, consulte Introdução ao IAM Roles Anywhere. Crie uma variável de ambiente para armazenar o ARN da âncora de confiança:

    export TRUST_ANCHOR_ARN=trustAnchorArn

  2. Crie um arquivo chamado trust-policy.json contendo a seguinte política de confiança:

    JSON
    JSON
    {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "TrustPolicyForSelfManagedOrOnPremiseClusters",
            "Effect": "Allow",
            "Principal": {
                "Service": "rolesanywhere.amazonaws.com"
            },
            "Action": [
                "sts:AssumeRole",
                "sts:SetSourceIdentity",
                "sts:TagSession"
            ],
            "Condition": {
                "ArnEquals": {
                    "aws:SourceArn": [
                        "arn:aws:rolesanywhere:us-east-1:123456789012:trust-anchor/TRUST_ANCHOR_ARN"
                    ]
                },
                "StringEquals": {
                    "aws:PrincipalTag/x509Subject/CN": "aws-privateca-issuer"
                }
            }
        }
    ]
}

  3. Execute os comandos a seguir para criar uma função do IAM:

    ROLE_ARN=$(aws iam create-role \
  --role-name CertManagerPrivateCARole \
  --assume-role-policy-document file://trust-policy.json \
  --query "Role.Arn" \
  --region $REGION \
  --output text)
  
 aws iam attach-role-policy \
  --role-name CertManagerPrivateCARole \
  --region $REGION \
  --policy-arn arn:aws:iam::aws:policy/AWSPrivateCAConnectorForKubernetesPolicy

Instalar e configurar o emissor CA Privada da AWS do cluster

Para instalar o aws-privateca-connector-for-kubernetes complemento, use os seguintes comandos:

Amazon EKS clusters

Crie o complemento:

aws eks create-addon --region $REGION \
  --cluster-name $CLUSTER \
  --addon-name aws-privateca-connector-for-kubernetes \
  --pod-identity-associations "[{
    \"serviceAccount\": \"aws-privateca-issuer\",
    \"roleArn\": \"$ROLE_ARN\"
  }]"

Em seguida, aguarde até que o complemento esteja ativo:

aws eks describe-addon \
  --cluster-name $CLUSTER \
  --addon-name aws-privateca-connector-for-kubernetes \
  --region $REGION \
  --query 'addon.status'
Other clusters

  1. Crie um perfil em IAM Roles Anywhere:

    PROFILE_ARN=$(aws rolesanywhere create-profile \
  --name "privateca-profile" \
  --role-arns "$ROLE_ARN" \
  --region "$REGION" \
  --query 'profile.profileArn' \
  --enabled \
  --output text)

  2. Gere um certificado de cliente para uso com o Connector for Kubernetes e para IAM Roles Anywhere autenticar com: CA Privada da AWS

    1. Gere uma chave privada para o certificado do cliente:

      openssl genrsa -out client.key 2048

    2. Gere uma solicitação de assinatura de certificado (CSR) para o certificado do cliente:

      openssl req -new \
  -key client.key \
  -out client.csr \
  -subj "/CN=aws-privateca-issuer"

    3. Emita o certificado do cliente de CA Privada da AWS:

      CERT_ARN=$(aws acm-pca issue-certificate \
  --signing-algorithm SHA256WITHRSA \
  --csr fileb://client.csr \
  --validity Value=1,Type=DAYS \
  --certificate-authority-arn "$CA_ARN" \
  --region "$REGION" \
  --query 'CertificateArn' \
  --output text)

    4. Armazene o certificado do cliente localmente:

      aws acm-pca get-certificate \
  --certificate-authority-arn $CA_ARN \
  --certificate-arn $CERT_ARN \
  --region $REGION \
  --query 'Certificate' 
  --output text > pca-issuer-client-cert.pem

  3. Instale o CA Privada da AWS emissor no cluster com o certificado do cliente:

    1. Adicione o repositório do awspca Helm:

      helm repo add awspca https://cert-manager.github.io/aws-privateca-issuer 
helm repo update

    2. Crie um namespace:

      kubectl create namespace aws-privateca-issuer

    3. Coloque o certificado criado anteriormente em um segredo:

      kubectl create secret tls aws-privateca-credentials \
  -n aws-privateca-issuer \
  --cert=pca-issuer-client-cert.pem \
  --key=client.key

  4. Instale o CA Privada da AWS emissor com IAM Roles Anywhere:

    1. Crie um arquivo chamado values.yaml para configurar o plug-in do CA Privada da AWS emissor a ser usado com IAM Roles Anywhere: 

      cat > values.yaml <<EOF
env:
  AWS_EC2_METADATA_SERVICE_ENDPOINT: "http://127.0.0.1:9911"

extraContainers:
  - name: "rolesanywhere-credential-helper"
    image: "public.ecr.aws/rolesanywhere/credential-helper:latest"
    command: ["aws_signing_helper"]
    args:
      - "serve"
      - "--private-key"
      - "/etc/cert/tls.key"
      - "--certificate"
      - "/etc/cert/tls.crt"
      - "--role-arn"
      - "$ROLE_ARN"
      - "--profile-arn"
      - "$PROFILE_ARN"
      - "--trust-anchor-arn"
      - "$TRUST_ANCHOR_ARN"
    volumeMounts:
      - name: cert
        mountPath: /etc/cert/
        readOnly: true

volumes:
  - name: cert
    secret:
      secretName: aws-privateca-credentials
EOF

    2. Instale o CA Privada da AWS emissor com IAM Roles Anywhere:

      helm install aws-privateca-issuer awspca/aws-privateca-issuer \
  -n aws-privateca-issuer \
  -f values.yaml

Aguarde até que o emissor esteja pronto. Use o seguinte comando: 

kubectl wait --for=condition=ready pods --all -n aws-privateca-issuer --timeout=120s

Em seguida, verifique a instalação para garantir que todos os pods tenham atingido o READY estado:

kubectl -n aws-privateca-issuer get all

Para configurar oaws-private-ca-cluster-issuer, crie um arquivo YAML chamado cluster-issuer.yaml contendo a configuração do emissor:

cat > cluster-issuer.yaml <<EOF
apiVersion: awspca.cert-manager.io/v1beta1
kind: AWSPCAClusterIssuer
metadata:
  name: aws-privateca-cluster-issuer
spec:
  arn: "$CA_ARN"
  region: "$REGION"
EOF

Em seguida, aplique a configuração do cluster:

kubectl apply -f cluster-issuer.yaml

Verifique o status do emissor:

kubectl describe awspcaclusterissuer aws-privateca-cluster-issuer

Você verá uma resposta semelhante à seguinte:

Status:
  Conditions:
    Last Transition Time:  2025-08-13T21:00:00Z
    Message:               AWS PCA Issuer is ready
    Reason:                Verified
    Status:                True
    Type:                  Ready

Gerencie o certificado CA Privada da AWS do cliente com o cert-manager

Se você não estiver usando um cluster Amazon EKS, depois de inicializar manualmente um certificado confiável, aws-privateca-issuer você poderá fazer a transição para um certificado de autenticação de cliente gerenciado porcert-manager. Isso permite cert-manager renovar automaticamente o certificado de autenticação do cliente.

  1. Crie um arquivo chamadopca-auth-cert.yaml:

    cat > pca-auth-cert.yaml <<EOF
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: aws-privateca-client-cert
  namespace: aws-privateca-issuer
spec:
  secretName: aws-privateca-credentials
  duration: 168h
  renewBefore: 48h
  commonName: aws-privateca-issuer
  privateKey:
    algorithm: ECDSA
    size: 256
    rotationPolicy: Always
  usages:
    - client auth
  issuerRef:
    name: aws-privateca-cluster-issuer
    kind: AWSPCAClusterIssuer
    group: awspca.cert-manager.io
EOF

  2. Crie o novo certificado de autenticação de cliente gerenciado:

    kubectl apply -f pca-auth-cert.yaml

  3. Valide se o certificado foi criado:

    kubectl get certificate aws-privateca-client-cert -n aws-privateca-issuer

    Você verá uma resposta semelhante à seguinte:

    NAME                        READY   SECRET                      AGE
aws-privateca-client-cert   True    aws-privateca-credentials   19m

Emita seu primeiro certificado TLS

Agora que o cert-manager e aws-privateca-issuer está instalado, você pode emitir um certificado.

Crie um arquivo YAML chamado certificate.yaml contendo o recurso de certificado:

cat > certificate.yaml <<EOF
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: example-certificate
  namespace: default
spec:
  secretName: example-certificate-tls
  issuerRef:
    name: aws-privateca-cluster-issuer
    kind: AWSPCAClusterIssuer
    group: awspca.cert-manager.io
  commonName: example.internal
  dnsNames:
    - example.internal
    - api.example.internal
  duration: 2160h # 90 days
  renewBefore: 360h # 15 days
  usages:
    - digital signature
    - key encipherment
    - server auth
EOF

Aplique o certificado usando o seguinte comando:

kubectl apply -f certificate.yaml

Em seguida, você pode verificar o status do certificado com os seguintes comandos:

kubectl get certificate example-certificate
kubectl describe certificate example-certificate

Você deve ver uma resposta semelhante a esta:

NAME                 READY   SECRET                    AGE
example-certificate  True    example-certificate-tls   30s

Você pode inspecionar o certificado emitido com o seguinte comando:

kubectl get secret example-certificate-tls -o yaml

Você também pode decodificar e examinar o certificado com o seguinte comando:

kubectl get secret example-certificate-tls -o jsonpath='{.data.tls\.crt}' | base64 -d | openssl x509 -text -noout