Commencez avec AWS CA privée Connector pour Kubernetes. - AWS Autorité de certification privée
Installer cert-managerConfiguration des autorisations IAMInstallation et configuration de l'émetteur AWS CA privée du clusterGérez le certificat AWS CA privée client avec cert-managerÉmettez votre premier certificat TLS

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Commencez avec AWS CA privée Connector pour Kubernetes.

Les rubriques suivantes montrent comment AWS CA privée sécuriser les communications dans un cluster Kubernetes. Pour un autre exemple, reportez-vous à la section Chiffrement en transit pour Kubernetes activé. GitHub

Vous pouvez utiliser une autorité de certification privée pour sécuriser les communications avec vos clusters Amazon EKS. Avant de commencer, vérifiez que vous disposez des éléments suivants :

  • Un AWS compte doté des autorisations appropriées adaptées à vos politiques de sécurité.

    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. Pour créer un cluster Amazon Elastic Kubernetes Service, consultez le guide de démarrage rapide Amazon EKS. Pour plus de simplicité, créez une variable d'environnement contenant le nom du cluster :

    export CLUSTER=aws-privateca-demo

  • L' Région AWS emplacement de votre CA et de votre cluster Amazon EKS. Pour plus de simplicité, créez une variable d'environnement pour contenir la région :

    export REGION=aws-region

  • Le nom de ressource Amazon (ARN) d'une autorité de certification AWS CA privée privée. Pour plus de simplicité, créez une variable d'environnement contenant l'ARN CA privé :

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

    Pour créer une autorité de certification privée, reportez-vous à la section https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html Création d'une autorité de certification privée dans AWS CA privée

  • Un ordinateur sur lequel sont installés les logiciels suivants :

Installer cert-manager

Pour utiliser une autorité de certification privée, vous devez installer le cert-manager> module complémentaire qui demande les certificats, les distribue et automatise le renouvellement des certificats. Vous devez également installer le aws-private-ca-issuer plugin qui vous permet d'émettre des certificats privés à partir de AWS CA privée. Procédez comme suit pour installer le module complémentaire et le plug-in.

Amazon EKS clusters

Installation cert-manager en tant que module complémentaire Amazon EKS :

aws eks create-addon \
  --cluster-name $CLUSTER \
  --addon-name cert-manager \
  --region $REGION
Other clusters

Installation à cert-manager l'aide de 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

Configuration des autorisations IAM

Le aws-privateca-issuer plugin nécessite une autorisation pour interagir avec AWS CA privée. Pour les clusters Amazon EKS, vous utilisez l'identité du pod. Pour les autres clusters que vous utilisez AWS Identity and Access Management Roles Anywhere.

Créez d'abord une politique IAM. La stratégie utilise la stratégie AWSPrivateCAConnectorForKubernetesPolicy gérée. Pour plus d'informations sur la politique, reportez-vous AWSPrivateCAConnectorForKubernetesPolicyau guide de référence des politiques AWS gérées.

Amazon EKS clusters

  1. Créez un fichier nommé trust-policy.json contenant la politique de confiance suivante :

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

  2. Exécutez les commandes suivantes pour créer un rôle 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. Créez une ancre de confiance qui fait confiance à l'autorité de certification privée qui y est stockéeCA_ARN. Pour obtenir des instructions, reportez-vous à la section Mise en route avec IAM Roles Anywhere. Créez une variable d'environnement pour stocker l'ARN de l'ancre de confiance :

    export TRUST_ANCHOR_ARN=trustAnchorArn

  2. Créez un fichier appelé trust-policy.json contenant la politique de confiance suivante :

    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. Exécutez les commandes suivantes pour créer un rôle 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

Installation et configuration de l'émetteur AWS CA privée du cluster

Pour installer le aws-privateca-connector-for-kubernetes module complémentaire, utilisez les commandes suivantes :

Amazon EKS clusters

Créez le module complémentaire :

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

Attendez ensuite que le module complémentaire soit actif :

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

  1. Créez un profil dans 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. Générez un certificat client à utiliser avec le Connector for Kubernetes et IAM Roles Anywhere à authentifier auprès de : AWS CA privée

    1. Générez une clé privée pour le certificat client :

      openssl genrsa -out client.key 2048

    2. Générez une demande de signature de certificat (CSR) pour le certificat client :

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

    3. Émettez le certificat client auprès de AWS CA privée :

      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. Stockez le certificat client localement :

      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. Installez l' AWS CA privée émetteur dans le cluster avec le certificat client :

    1. Ajoutez le référentiel Helm awspca :

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

    2. Créez un espace de noms :

      kubectl create namespace aws-privateca-issuer

    3. Mettez le certificat créé précédemment dans un secret :

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

  4. Installez l' AWS CA privée émetteur avec IAM Roles Anywhere :

    1. Créez un fichier nommé values.yaml pour configurer le plugin AWS CA privée émetteur à utiliser avec 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. Installez l' AWS CA privée émetteur avec IAM Roles Anywhere :

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

Attendez que l'émetteur soit prêt. Utilisez la commande suivante : 

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

Vérifiez ensuite l'installation pour vous assurer que tous les pods ont atteint l'READYétat suivant :

kubectl -n aws-privateca-issuer get all

Pour configurer leaws-private-ca-cluster-issuer, créez un fichier YAML nommé cluster-issuer.yaml contenant la configuration de l'émetteur :

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

Appliquez ensuite la configuration du cluster :

kubectl apply -f cluster-issuer.yaml

Vérifiez le statut de l'émetteur :

kubectl describe awspcaclusterissuer aws-privateca-cluster-issuer

La réponse devrait être similaire à ce qui suit :

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

Gérez le certificat AWS CA privée client avec cert-manager

Si vous n'utilisez pas de cluster Amazon EKS, après avoir démarré manuellement un certificat sécurisé, aws-privateca-issuer vous pouvez passer à un certificat d'authentification client géré parcert-manager. Cela permet cert-manager de renouveler automatiquement le certificat d'authentification du client.

  1. Créez un fichier appelé 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

  2. Créez le nouveau certificat d'authentification client géré :

    kubectl apply -f pca-auth-cert.yaml

  3. Vérifiez que le certificat a été créé :

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

    La réponse devrait être similaire à ce qui suit :

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

Émettez votre premier certificat TLS

Maintenant que les cert-manager et aws-privateca-issuer sont installés, vous pouvez émettre un certificat.

Créez un fichier YAML nommé certificate.yaml contenant la ressource de certificat :

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

Appliquez le certificat à l'aide de la commande suivante :

kubectl apply -f certificate.yaml

Vous pouvez ensuite vérifier l'état du certificat à l'aide des commandes suivantes :

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

Vous devriez voir une réponse similaire à celle-ci :

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

Vous pouvez inspecter le certificat émis à l'aide de la commande suivante :

kubectl get secret example-certificate-tls -o yaml

Vous pouvez également décoder et examiner le certificat à l'aide de la commande suivante :

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