Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

I seguenti argomenti mostrano come utilizzare per proteggere le comunicazioni in AWS Private CA un cluster Kubernetes. Per un altro esempio, fai riferimento a [Encryption in transit for](https://github.com/aws-samples/sample-encryption-in-transit-for-kubernetes) Kubernetes on. GitHub

Puoi utilizzare un'autorità di certificazione privata per proteggere le comunicazioni con i tuoi cluster Amazon EKS. Prima di iniziare, assicurati di disporre di quanto riportato di seguito:
+ Un AWS account con le autorizzazioni appropriate nell'ambito delle tue politiche di sicurezza.

------
#### [ 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 cluster Kubernetes. [Per creare un cluster Amazon Elastic Kubernetes Service, consulta la guida rapida di Amazon EKS.](https://docs.aws.amazon.com/eks/latest/userguide/quickstart.html) Per semplicità, crea una variabile di ambiente che contenga il nome del cluster:

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

  
+ La posizione Regione AWS in cui si trovano il cluster CA e Amazon EKS. Per semplicità, crea una variabile di ambiente per contenere la regione:

  ```
  export REGION={{{{aws-region}}}}
  ```
+ L'Amazon Resource Name (ARN) di un'autorità di certificazione AWS Private CA privata. Per semplicità, crea una variabile di ambiente per contenere l'ARN CA privato:

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

  Per creare una CA privata, consulta [https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html](https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html) Creare una CA privata in AWS Private CA
+ Un computer con il seguente software installato:
  + [AWS CLI v2 configurato](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
  + [kubectl v1.13\+](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
  + [Per cluster non Amazon EKS, Helm v3](https://helm.sh/docs/intro/install/)

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

Per utilizzare una CA privata, è necessario installare il `cert-manager>` componente aggiuntivo che richiede i certificati, li distribuisce e automatizza il rinnovo dei certificati. È inoltre necessario installare il `aws-private-ca-issuer` plug-in che consente di emettere certificati privati da. AWS Private CA Utilizza i seguenti passaggi per installare il componente aggiuntivo e il plug-in.

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

Installa `cert-manager` come componente aggiuntivo Amazon EKS:

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

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

Installa `cert-manager` utilizzando 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
```

------

## Configurazione delle autorizzazioni IAM
<a name="kubernetes-iam-permissions"></a>

Il `aws-privateca-issuer` plugin richiede l'autorizzazione con AWS Private CA cui interagire. Per i cluster Amazon EKS si utilizza l'identità del pod. Per gli altri cluster che usi. AWS Identity and Access Management Roles Anywhere

Innanzitutto, crea una policy IAM. La policy utilizza la policy `AWSPrivateCAConnectorForKubernetesPolicy` gestita. Per ulteriori informazioni sulla policy, consulta la *guida [AWSPrivateCAConnectorForKubernetesPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPrivateCAConnectorForKubernetesPolicy.html)di riferimento alla policy AWS gestita*.

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

1. Crea un file denominato `trust-policy.json` contenente la seguente politica di fiducia:

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

****  

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

------

1. Esegui i seguenti comandi per creare un ruolo 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. Crea un trust anchor che consideri attendibile la CA privata archiviata in. `CA_ARN` Per istruzioni, consulta la sezione [Guida introduttiva](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html). IAM Roles Anywhere Crea una variabile di ambiente per memorizzare l'ARN del trust anchor:

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

1. Crea un file chiamato `trust-policy.json` contenente la seguente politica di fiducia:

------
#### [ 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. Esegui i seguenti comandi per creare un ruolo 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
   ```

------

## Installa e configura l'emittente del AWS Private CA cluster
<a name="kubernetes-install-aws-private-ca-cluster-issuer"></a>

Per installare il `aws-privateca-connector-for-kubernetes` componente aggiuntivo, utilizza i seguenti comandi: 

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

Crea il componente aggiuntivo:

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

Quindi attendi che il componente aggiuntivo sia attivo:

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

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

1. Crea un profilo in 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. Genera un certificato client da utilizzare con il Connector for Kubernetes e IAM Roles Anywhere per l'autenticazione con: AWS Private CA

   1. Genera una chiave privata per il certificato del client:

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

   1. Genera una richiesta di firma del certificato (CSR) per il certificato client:

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

   1. Emetti il certificato client da 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. Archivia il certificato client 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. Installa l' AWS Private CA emittente nel cluster con il certificato client:

   1. Aggiungere il repository Helm `awspca`:

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

   1. Crea uno spazio dei nomi:

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

   1. Metti il certificato creato in precedenza in un segreto:

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

1. Installa l' AWS Private CA emittente con IAM Roles Anywhere:

   1. Crea un file denominato `values.yaml` per configurare il plug-in dell' AWS Private CA emittente da utilizzare 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. Installa l' AWS Private CA emittente con: IAM Roles Anywhere

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

------

Attendi che l'emittente sia pronto. Utilizza il seguente comando: 

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

Quindi verifica l'installazione per assicurarti che tutti i pod abbiano raggiunto lo `READY` stato:

```
kubectl -n aws-privateca-issuer get all
```

Per configurare`aws-private-ca-cluster-issuer`, create un file YAML denominato `cluster-issuer.yaml` contenente la configurazione dell'emittente:

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

Quindi, applica la configurazione del cluster:

```
kubectl apply -f cluster-issuer.yaml
```

Verifica lo stato dell'emittente:

```
kubectl describe awspcaclusterissuer aws-privateca-cluster-issuer
```

Noterai una risposta simile alla seguente:

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

## Gestisci il certificato del AWS Private CA client con cert-manager
<a name="kubernetes-manage-pca-certificate"></a>

Se non utilizzi un cluster Amazon EKS, dopo aver avviato manualmente un certificato affidabile `aws-privateca-issuer` puoi passare a un certificato di autenticazione client gestito da`cert-manager`. Ciò consente di `cert-manager` rinnovare automaticamente il certificato di autenticazione del client.

1. Crea un file chiamato`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. Crea il nuovo certificato di autenticazione del client gestito:

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

1. Verifica che il certificato sia stato creato:

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

   Noterai una risposta simile alla seguente:

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

## Emetti il tuo primo certificato TLS
<a name="kubernetes-issue-certificate"></a>

Ora che i `cert-manager` e `aws-privateca-issuer` sono installati, puoi emettere un certificato.

Crea un file YAML denominato `certificate.yaml` contenente la risorsa del certificato:

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

Applica il certificato utilizzando il seguente comando:

```
kubectl apply -f certificate.yaml
```

È quindi possibile controllare lo stato del certificato con i seguenti comandi:

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

Dovresti vedere una risposta simile a questa:

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

È possibile controllare il certificato emesso con il seguente comando:

```
kubectl get secret example-certificate-tls -o yaml
```

Puoi anche decodificare ed esaminare il certificato con il seguente comando:

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