Instale cert-manager Configurar los permisos de IAM Instale y configure el emisor del AWS Private CA clúster Administre el certificado del AWS Private CA cliente con cert-manager Emita su primer certificado TLS

Comience a utilizar AWS Private CA Connector for Kubernetes.

En los siguientes temas, se muestra cómo utilizarlos AWS Private CA para proteger las comunicaciones en un clúster de Kubernetes. Para ver otro ejemplo, consulta Encryption in transit for Kubernetes on. GitHub

Puede utilizar una autoridad de certificación privada para proteger las comunicaciones con sus clústeres de Amazon EKS. Antes de comenzar, asegúrese de que dispone de lo siguiente:

Una AWS cuenta con los permisos adecuados dentro del ámbito de sus políticas de seguridad.

Un clúster de Kubernetes. Para crear un clúster de Amazon Elastic Kubernetes Service, consulte la guía de inicio rápido de Amazon EKS. Para simplificar, cree una variable de entorno que contenga el nombre del clúster:
```
export CLUSTER=aws-privateca-demo
```
El Región de AWS lugar donde se encuentran su clúster de CA y Amazon EKS. Para simplificar, cree una variable de entorno que contenga la región:
```
export REGION=aws-region
```
El nombre de recurso de Amazon (ARN) de una entidad de certificación AWS Private CA privada. Para simplificar, cree una variable de entorno que contenga el ARN de CA privado:
```
export CA_ARN="arn:aws:acm-pca:region:account:certificate-authority/CA_ID/certificate/certificate_ID"
```
Para crear una CA privada, consulte https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html Crear una CA privada en AWS Private CA
Un ordenador con el siguiente software instalado:
- AWS CLI v2 configurado
- kubectl v1.13+
- Para clústeres que no son de Amazon EKS, Helm v3

Instale cert-manager

Para usar una CA privada, debe instalar el cert-manager> complemento que solicita los certificados, los distribuye y automatiza la renovación de los certificados. También debe instalar el aws-private-ca-issuer complemento que le permite emitir certificados privados desde. AWS Private CA Siga los siguientes pasos para instalar el complemento y el complemento.

Configurar los permisos de IAM

El aws-privateca-issuer complemento requiere permiso para interactuar con él AWS Private CA. Para los clústeres de Amazon EKS, utilice la identidad del pod. Para otros clústeres, utilice AWS Identity and Access Management Roles Anywhere.

En primer lugar, cree una política de IAM. La política utiliza la política AWSPrivateCAConnectorForKubernetesPolicy gestionada. Para obtener más información sobre la política, consulte la guía AWSPrivateCAConnectorForKubernetesPolicyde referencia de políticas AWS gestionadas.

Amazon EKS clusters

Cree un archivo con el nombre trust-policy.json que contenga la siguiente política de confianza:

JSON

JSON


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

Ejecute los siguientes comandos para crear un rol de 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

Cree un ancla de confianza que confíe en la CA privada en CA_ARN la que está almacenada. Para obtener instrucciones, consulte Cómo empezar con IAM Roles Anywhere. Cree una variable de entorno para almacenar el ARN del ancla de confianza:
```
export TRUST_ANCHOR_ARN=trustAnchorArn
```

Cree un archivo trust-policy.json que contenga la siguiente política de confianza:

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"
                }
            }
        }
    ]
}

Ejecute los siguientes comandos para crear un rol de 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

Instale y configure el emisor del AWS Private CA clúster

Para instalar el aws-privateca-connector-for-kubernetes complemento, utilice los siguientes comandos:

Amazon EKS clusters

Crea el 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\"
  }]"

A continuación, espera a que el complemento esté activo:


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

Other clusters

Crea un perfil en IAM Roles Anywhere:


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

Genere un certificado de cliente para usarlo con el Connector for Kubernetes y para IAM Roles Anywhere autenticarse con: AWS Private CA

Genere una clave privada para el certificado de cliente:
```
openssl genrsa -out client.key 2048
```

Genere una solicitud de firma de certificado (CSR) para el certificado del cliente:


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

Emita el certificado de cliente desde AWS Private CA:


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)

Guarde el certificado de 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

Instale el AWS Private CA emisor en el clúster con el certificado de cliente:

Agregue el repositorio awspca de Helm:


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

Cree un espacio de nombres:


kubectl create namespace aws-privateca-issuer

Guarde el certificado creado anteriormente en un secreto:


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

Instale el AWS Private CA emisor con IAM Roles Anywhere:

Cree un archivo con el nombre values.yaml correspondiente a la configuración del complemento AWS Private CA emisor para usarlo con: 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

Instale el AWS Private CA emisor con: IAM Roles Anywhere


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

Espere a que el emisor esté listo. Utilice el siguiente comando :


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

Y, a continuación, verifica la instalación para asegurarte de que todos los pods hayan alcanzado el READY estado siguiente:


kubectl -n aws-privateca-issuer get all

Para configurarlosaws-private-ca-cluster-issuer, crea un archivo YAML con un nombre cluster-issuer.yaml que contenga la configuración del emisor:


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

A continuación, aplique la configuración del clúster:


kubectl apply -f cluster-issuer.yaml

Compruebe el estado del emisor:


kubectl describe awspcaclusterissuer aws-privateca-cluster-issuer

Verá una respuesta parecida a la siguiente:


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

Administre el certificado del AWS Private CA cliente con cert-manager

Si no utiliza un clúster de Amazon EKS, después de iniciar manualmente un certificado de confianza, aws-privateca-issuer puede realizar la transición a un certificado de autenticación de cliente gestionado porcert-manager. Esto permite cert-manager renovar automáticamente el certificado de autenticación del cliente.

Cree un archivo llamadopca-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

Cree el nuevo certificado de autenticación de cliente administrado:
```
kubectl apply -f pca-auth-cert.yaml
```

Valide que se haya creado el certificado:


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

Verá una respuesta parecida a la siguiente:


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

Emita su primer certificado TLS

Ahora que los cert-manager y aws-privateca-issuer están instalados, puede emitir un certificado.

Cree un archivo YAML con el nombre certificate.yaml que contenga el recurso del 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 el certificado mediante el siguiente comando:


kubectl apply -f certificate.yaml

A continuación, puede comprobar el estado del certificado con los siguientes comandos:


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

Deberías ver una respuesta similar a esta:


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

Puede inspeccionar el certificado emitido con el siguiente comando:


kubectl get secret example-certificate-tls -o yaml

También puede decodificar y examinar el certificado con el siguiente comando:


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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Consideraciones

Ejemplos