Inizia a usare AWS Private CA Connector for Kubernetes. - AWS Private Certificate Authority
Installa cert-managerConfigurazione delle autorizzazioni IAMInstalla e configura l'emittente del AWS Private CA clusterGestisci il certificato del AWS Private CA client con cert-managerEmetti il tuo primo certificato TLS

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.

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

  • Un cluster Kubernetes. Per creare un cluster Amazon Elastic Kubernetes Service, consulta la guida rapida di Amazon EKS. 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 Creare una CA privata in AWS Private CA

  • Un computer con il seguente software installato:

Installa cert-manager

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

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 AWSPrivateCAConnectorForKubernetesPolicydi riferimento alla policy AWS gestita.

Amazon EKS clusters

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

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

  2. 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. IAM Roles Anywhere Crea una variabile di ambiente per memorizzare l'ARN del trust anchor:

    export TRUST_ANCHOR_ARN=trustAnchorArn

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

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

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)

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

    2. 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"

    3. 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)

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

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

    2. Crea uno spazio dei nomi:

      kubectl create namespace aws-privateca-issuer

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

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

    2. 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 configurareaws-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

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 dacert-manager. Ciò consente di cert-manager rinnovare automaticamente il certificato di autenticazione del client.

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

    kubectl apply -f pca-auth-cert.yaml

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

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