本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 开始使用适用于 Kubernetes 的 Amazon 私有 CA 连接器。
开始使用

以下主题介绍如何使用 Amazon 私有 CA 来保护 Kubernetes 集群中的通信。有关另一个示例，请参阅开启的 [Kubernetes 传输中的加密](https://github.com/aws-samples/sample-encryption-in-transit-for-kubernetes)。 GitHub

您可以使用私有证书颁发机构来保护与 Amazon EKS 集群的通信。在您开始之前，请确保您已拥有以下各项：
+ 具有适当权限的 Amazon 账户，其范围仅限于您的安全策略。

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

------

------
+ 一个 Kubernetes 集群。[要创建亚马逊 Elastic Kubernetes Service 集群，请参阅亚马逊 EKS 快速入门指南。](https://docs.amazonaws.cn/eks/latest/userguide/quickstart.html)为简单起见，创建一个环境变量来保存集群名称：

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

  
+ 您的 Amazon Web Services 区域 CA 和 Amazon EKS 集群所在的位置。为简单起见，创建一个环境变量来保存区域：

  ```
  export REGION=aws-region
  ```
+  Amazon 私有 CA 私有证书颁发机构的亚马逊资源名称 (ARN)。为简单起见，创建一个环境变量来保存私有 CA ARN：

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

  要创建私有 CA，请参阅中的[https://docs.amazonaws.cn/privateca/latest/userguide/create-CA.html](https://docs.amazonaws.cn/privateca/latest/userguide/create-CA.html)创建私有 CA Amazon 私有 CA
+ 一台安装了以下软件的计算机：
  + Amazon CLI 已@@ [配置 v2](https://docs.amazonaws.cn/cli/latest/userguide/cli-chap-install.html)
  + [kubectl v1.13\$1](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
  + 对于非亚马逊 EKS 集群，[Helm v3](https://helm.sh/docs/intro/install/)

## 安装证书管理器


要使用私有 CA，必须安装请求证书、分发证书和自动续订证书的`cert-manager>`插件。您还必须安装允许您从中颁发私有证书的`aws-private-ca-issuer`插件 Amazon 私有 CA。使用以下步骤安装插件和插件。

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

`cert-manager`作为 Amazon EKS 附加组件安装：

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

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

`cert-manager`使用 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
```

------

## 配置 IAM 权限


该`aws-privateca-issuer`插件需要与之交互的权限 Amazon 私有 CA。对于 Amazon EKS 集群，您可以使用容器身份。对于您使用的其他集群 Amazon Identity and Access Management Roles Anywhere。

首先，创建一个 IAM 策略。该策略使用`AWSPrivateCAConnectorForKubernetesPolicy`托管策略。有关该策略的更多信息，请参阅[AWSPrivateCAConnectorForKubernetesPolicy](https://docs.amazonaws.cn/aws-managed-policy/latest/reference/AWSPrivateCAConnectorForKubernetesPolicy.html)《*Amazon 托管策略参考指南》*。

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

1. 创建一个名为的文件，`trust-policy.json`其中包含以下信任策略：

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

****  

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

------

1. 运行以下命令创建 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. 创建信任存储在中的私有 CA 的信任锚`CA_ARN`。有关说明，请参阅[入门 IAM Roles Anywhere](https://docs.amazonaws.cn/rolesanywhere/latest/userguide/getting-started.html)。创建一个环境变量来存储信任锚点 ARN：

   ```
   export TRUST_ANCHOR_ARN=trustAnchorArn
   ```

1. 创建一个名为的文件，`trust-policy.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"
                   }
               }
           }
       ]
   }
   ```

------

1. 运行以下命令创建 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
   ```

------

## 安装和配置 Amazon 私有 CA 集群发行者


要安装该`aws-privateca-connector-for-kubernetes`插件，请使用以下命令：

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

创建插件：

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

然后等待插件激活：

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

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

1. 在以下位置创建个人资料 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. 生成客户端证书，用于 Kubernetes 的连接器使用，并通过以下方式 IAM Roles Anywhere 进行身份验证： Amazon 私有 CA

   1. 为客户证书生成私钥：

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

   1. 为客户端证书生成证书签名请求 (CSR)：

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

   1. 从 Amazon 私有 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. 将客户端证书存储在本地：

      ```
      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. 使用客户端证书在集群中安装 Amazon 私有 CA 发行者：

   1. 添加 `awspca` Helm 存储库：

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

   1. 创建命名空间：

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

   1. 将之前创建的证书放入密钥中：

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

1. 使用以下命令安装 Amazon 私有 CA 发行者 IAM Roles Anywhere：

   1. 创建一个名为的文件`values.yaml`，将 Amazon 私有 CA 发行者插件配置为与以下内容一起使用 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. 使用以下命令安装 Amazon 私有 CA 发行者 IAM Roles Anywhere：

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

------

等待发行人准备就绪。使用以下命令：

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

然后验证安装以确保所有 pod 都已达到`READY`状态：

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

要配置`aws-private-ca-cluster-issuer`，请创建一个名为的 YAML 文件，`cluster-issuer.yaml`其中包含颁发者的配置：

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

接下来，应用集群配置：

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

检查发行人的状态：

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

您可以看到类似以下内容的响应：

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

## 使用证书管理器管理 Amazon 私有 CA 客户证书


如果您未使用 Amazon EKS 集群，则在中手动引导可信证书后，`aws-privateca-issuer`您可以过渡到由`cert-manager`管理的客户端身份验证证书。这`cert-manager`允许自动续订客户端身份验证证书。

1. 创建一个名为`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. 创建新的托管客户端身份验证证书：

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

1. 验证证书是否已创建：

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

   您可以看到类似以下内容的响应：

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

## 颁发您的第一个 TLS 证书


现在`cert-manager`和已安装`aws-privateca-issuer`完毕，您可以颁发证书。

创建一个名为的 YAML 文件，`certificate.yaml`其中包含证书资源：

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

使用以下命令应用证书：

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

然后，您可以使用以下命令检查证书的状态：

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

您应该会看到类似于以下内容的响应：

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

您可以使用以下命令检查已颁发的证书：

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

您也可以使用以下命令解码和检查证书：

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