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à.

# Proteggi Kubernetes con AWS Autorità di certificazione privata
<a name="PcaKubernetes"></a>

Puoi utilizzarlo AWS Autorità di certificazione privata per fornire certificati per l'autenticazione e la crittografia sicure su TLS e MTL. AWS Private CA fornisce un plug-in open source, [AWS Private CA Connector for Kubernetes](https://github.com/cert-manager/aws-privateca-issuer), (`aws-privateca-issuer`) per il componente aggiuntivo [cert-manager](https://cert-manager.io/docs/) ampiamente adottato di Kubernetes che richiede i certificati, li distribuisce nei segreti di Kubernetes e automatizza il rinnovo dei certificati.

Il plugin consente `aws-privateca-issuer` di emettere certificati tramite. AWS Private CA `cert-manager` Puoi utilizzare il plug-in con Amazon Elastic Kubernetes Service (Amazon EKS), un cluster Kubernetes autogestito su o in un cluster Kubernetes locale. AWS Il plugin funziona su entrambe le architetture x86 e ARM.

AWS Private CA ha chiavi supportate da HSM che non possono essere esportate. Se disponi di requisiti normativi per il controllo degli accessi e la verifica delle operazioni della CA, puoi utilizzarli AWS Private CA per migliorare la verificabilità e supportare la conformità.

**Nota**  
Se utilizzi Amazon EKS, ti consigliamo di utilizzare `aws-privateca-connector-for-kubernetes` i `cert-manager` componenti aggiuntivi per un'esperienza di installazione gestita. Per ulteriori informazioni, consulta i [AWS componenti aggiuntivi](https://docs.aws.amazon.com/eks/latest/userguide/workloads-add-ons-available-eks.html#add-ons-aws-privateca-connector).

# Concetti
<a name="PcaKubernetes-concepts"></a>

Il diagramma seguente mostra alcune delle opzioni disponibili per l'utilizzo di TLS in un cluster Amazon EKS. Il cluster di esempio si trova dietro un sistema di bilanciamento del carico. I numeri identificano i possibili endpoint per le comunicazioni protette da TLS.

![\[Un diagramma che mostra i possibili endpoint per la crittografia TLS. Ogni endpoint ha un numero che corrisponde all'elenco seguente.\]](http://docs.aws.amazon.com/it_it/privateca/latest/userguide/images/kubernetes-pca.png)


1. **Interruzione presso il sistema di bilanciamento del carico**

   Elastic Load Balancing (Elastic Load Balancing) è integrato con il servizio. AWS Certificate Manager Non è necessario installarlo `cert-manager` sul sistema di bilanciamento del carico. Puoi effettuare il provisioning di ACM con una CA privata, firmare un certificato con la CA privata e installare il certificato utilizzando la console Elastic Load Balancing. AWS Private CA i certificati vengono rinnovati automaticamente.

   In alternativa, puoi fornire un certificato privato a un sistema che non prevede il AWS bilanciamento del carico per terminare TLS.

   Ciò fornisce una comunicazione crittografata tra un client remoto e il sistema di bilanciamento del carico. I dati dopo il bilanciamento del carico sono stati passati non crittografati al cluster Amazon EKS.

1. **Terminazione presso il controller di ingresso Kubernetes**

   Il controller di ingresso si trova all'interno del cluster Amazon EKS e funge da sistema di bilanciamento del carico e router. Per utilizzare il controller di ingresso come endpoint del cluster per le comunicazioni esterne, devi:
   + Installa entrambi e `cert-manager` `aws-privateca-issuer` 
   + Fornisci al controller un certificato privato TLS da. AWS Private CA

   Le comunicazioni tra il load balancer e il controller di ingresso sono crittografate, i dati vengono trasmessi in modo non crittografato alle risorse del cluster.

1. **Terminazione presso un pod**

   Ogni pod è un gruppo di uno o più contenitori che condividono risorse di archiviazione e di rete. Se installi entrambi `cert-manager` `aws-privateca-issuer` e fornisci al cluster una CA privata, Kubernetes può installare un certificato privato TLS firmato sui pod, se necessario. Per impostazione predefinita, una connessione TLS che termina su un pod non è disponibile per gli altri pod del cluster. 

1. **Comunicazioni sicure tra i pod.**

   È possibile fornire certificati a più pod per consentire loro di comunicare tra loro. Gli scenari possibili sono i seguenti:
   + Il provisioning con certificati autofirmati generati da Kubernetes. Ciò protegge le comunicazioni tra i pod, ma i certificati autofirmati non soddisfano i requisiti HIPAA o FIPS.
   + Fornitura con certificati firmati da. AWS Private CA Ciò richiede l'installazione di entrambi `cert-manager` e`aws-privateca-issuer`. Kubernetes può quindi installare certificati MTLS firmati sui pod, se necessario.

# Considerazioni
<a name="PcaKubernetes-considerations"></a>

Quando lo utilizzi AWS Autorità di certificazione privata con Kubernetes, tieni a mente le seguenti considerazioni.

## Uso di cert-manager su più account
<a name="kubernetes-cross-account"></a>

Gli amministratori con accesso a una CA su più account possono utilizzare il componente `cert-manager` aggiuntivo per Kubernetes per fornire certificati per un cluster utilizzando la CA condivisa. Per ulteriori informazioni, vedi [Procedure consigliate di sicurezza per l'accesso ai dati privati da più account CAs](pca-resource-sharing.md).

È possibile utilizzare solo determinati modelli di AWS Private CA certificato in scenari con più account.

La tabella seguente elenca i CA privata AWS modelli che puoi utilizzare con cert-manager per effettuare il provisioning di un cluster Kubernetes.


| Modelli supportati per Kubernetes | Support per l'utilizzo su più account | 
| --- | --- | 
| [BlankEndEntityCertificateDefinizione \$1 CSRPassthrough /V1](template-definitions.md#BlankEndEntityCertificate_CSRPassthrough) | No | 
| [CodeSigningCertificateDefinizione /V1](template-definitions.md#CodeSigningCertificate-V1) | No | 
| [EndEntityCertificateDefinizione /V1](template-definitions.md#EndEntityCertificate-V1) | Sì | 
| [EndEntityClientAuthCertificateDefinizione /V1](template-definitions.md#EndEntityClientAuthCertificate-V1) | Sì | 
| [EndEntityServerAuthCertificateDefinizione /V1](template-definitions.md#EndEntityServerAuthCertificate-V1) | Sì | 
| [OCSPSigningDefinizione del certificato/V1](template-definitions.md#OCSPSigningCertificate-V1) | No | 

# 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\$1](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
```

# Esempi
<a name="PcaKubernetes-examples"></a>

Gli esempi seguenti mostrano come AWS Private CA può essere utilizzato con i cluster Kubernetes.

**Topics**
+ [Esempio: crittografia in transito per Kubernetes](https://github.com/aws-samples/sample-encryption-in-transit-for-kubernetes?tab=readme-ov-file)
+ [Cluster Kubernetes abilitati per TLS con e Amazon EKS CA privata AWS](https://go.aws/3ifFNEJ)
+ [Configurazione della crittografia end-to-end TLS su Amazon EKS con il nuovo AWS Load Balancer Controller](https://aws.amazon.com/blogs/containers/setting-up-end-to-end-tls-encryption-on-amazon-eks-with-the-new-aws-load-balancer-controller/)

# Monitora Kubernetes con AWS Private CA
<a name="PcaKubernetes-monitor"></a>

Per monitorare la CA privata del cluster Kubernetes, utilizza le tecniche descritte in. [Monitora AWS Private CA le risorse](logging-and-monitoring.md) Puoi utilizzare quanto segue per monitorare una CA privata:
+ [AWS Private CA CloudWatch metricheAWS Private CA CloudWatch metriche](PcaCloudWatch.md)
+ [Monitora AWS Private CA con eventi CloudWatch](CloudWatchEvents.md)
+ [Registrazione delle chiamate AWS Autorità di certificazione privata API utilizzando AWS CloudTrail](logging-using-cloudtrail-pca.md)

# Risolvi i problemi di Kubernetes con AWS Private CA
<a name="PcaKubernetes-troubleshoot"></a>

Puoi ottenere i log per `aws-private-ca-issuer` con la seguente procedura:

1. Ottieni il nome del pod:

   ```
   kubectl get pods -A
   ```

1. Per visualizzare i log dell'emittente, utilizzate il seguente comando:

   ```
   kubectl logs -n aws-privateca-issuer <pod-name> aws-privateca-issuer
   ```

1. Per visualizzare i IAM Roles Anywhere log, utilizzate il seguente comando:

   ```
   kubectl logs -n aws-privateca-issuer <pod-name> rolesanywhere-credentials-helper
   ```

Per verificare lo stato dell' AWS Private CA emittente, utilizzate uno dei seguenti strumenti:

**Per verificare che l'emittente sia pronto, utilizzate il seguente comando:**

```
kubectl get AWSPCAClusterIssuers -o json | jq '.items[].status
```

La risposta dovrebbe essere simile alla seguente:

```
{
  "conditions": [
    {
      "lastTransitionTime": "2024-07-03T13:56:37Z",
      "message": "Issuer verified",
      "reason": "Verified",
      "status": "True",
      "type": "Ready"
    }
  ]
}
```

Se l'emittente non si trova `Ready` nello stato, il `message` campo fornisce informazioni sul motivo per cui l'emittente non è riuscito a raggiungere lo `Ready` stato.

**Per verificare che il certificato sia pronto, usa il seguente comando:**

```
kubectl get certificates -o json | jq '.items[].status'
```

La risposta dovrebbe essere simile alla seguente:

```
{
  "conditions": [
    {
      "lastTransitionTime": "2024-07-03T13:58:13Z",
      "message": "Certificate is up to date and has not expired",
      "observedGeneration": 1,
      "reason": "Ready",
      "status": "True",
      "type": "Ready"
    }
  ],
  "notAfter": "2024-10-01T13:58:12Z",
  "notBefore": "2024-07-03T12:58:12Z",
  "renewalTime": "2024-09-16T13:58:12Z",
  "revision": 1
}
```

Se il certificato non è `Ready` nello stato, il `message` campo fornisce informazioni sul motivo per cui il certificato non è stato in grado di raggiungere lo `Ready` stato.