Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Comience con AWS Private CA Connector for Kubernetes.
<a name="PcaKubernetes-get-started"></a>

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](https://github.com/aws-samples/sample-encryption-in-transit-for-kubernetes) 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.

------
#### [ Amazon EKS clusters ]

------
#### [ 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 ]

****  

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

------

------
+ 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.](https://docs.aws.amazon.com/eks/latest/userguide/quickstart.html) Para simplificar, cree una variable de entorno que contenga el nombre del clúster:

  ```
  export CLUSTER={{aws-privateca-demo}}
  ```

  
+ La Región de AWS ubicación de 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](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](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) configurado
  + [kubectl v1.13\+](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
  + Para clústeres que no son de Amazon EKS, [Helm v3](https://helm.sh/docs/intro/install/)

## Instale cert-manager
<a name="kubernetes-install-cert-manager"></a>

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.

------
#### [ Amazon EKS clusters ]

Instálelo `cert-manager` como complemento de Amazon EKS:

```
aws eks create-addon \
  --cluster-name {{$CLUSTER}} \
  --addon-name cert-manager \
  --region $REGION
```

------
#### [ Other clusters ]

Instálelo `cert-manager` con 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 los permisos de IAM
<a name="kubernetes-iam-permissions"></a>

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 [AWSPrivateCAConnectorForKubernetesPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPrivateCAConnectorForKubernetesPolicy.html)de referencia de políticas AWS gestionadas*.

------
#### [ Amazon EKS clusters ]

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

------
#### [ JSON ]

****  

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

------

1. 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 ]

1. 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](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html). Cree una variable de entorno para almacenar el ARN del ancla de confianza:

   ```
   export TRUST_ANCHOR_ARN={{trustAnchorArn}}
   ```

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

------
#### [ 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"
                   }
               }
           }
       ]
   }
   ```

------

1. 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
<a name="kubernetes-install-aws-private-ca-cluster-issuer"></a>

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

Luego 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 ]

1. 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)
   ```

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

   1. Genere una clave privada para el certificado de cliente:

      ```
      openssl genrsa -out client.key 2048
      ```

   1. 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"
      ```

   1. 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)
      ```

   1. 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
      ```

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

   1. Agregue el repositorio `awspca` de Helm:

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

   1. Cree un espacio de nombres:

      ```
      kubectl create namespace aws-privateca-issuer
      ```

   1. Guarde el certificado creado anteriormente en secreto:

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

1. Instale el AWS Private CA emisor con IAM Roles Anywhere:

   1. Cree un archivo con el nombre `values.yaml` necesario para configurar el 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
      ```

   1. 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 configurarlos`aws-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
<a name="kubernetes-manage-pca-certificate"></a>

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 por`cert-manager`. Esto permite `cert-manager` renovar automáticamente el certificado de autenticación del cliente.

1. Cree un archivo llamado`pca-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
   ```

1. Cree el nuevo certificado de autenticación de cliente administrado:

   ```
   kubectl apply -f pca-auth-cert.yaml
   ```

1. 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
<a name="kubernetes-issue-certificate"></a>

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
```