Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

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

Topik berikut menunjukkan cara menggunakan AWS Private CA untuk mengamankan komunikasi di klaster Kubernetes. Untuk contoh lain, lihat [Enkripsi dalam perjalanan untuk Kubernetes](https://github.com/aws-samples/sample-encryption-in-transit-for-kubernetes) on. GitHub

Anda dapat menggunakan otoritas sertifikat pribadi untuk mengamankan komunikasi dengan kluster Amazon EKS Anda. Sebelum Anda mulai, pastikan Anda memiliki yang berikut:
+  AWS Akun dengan izin yang sesuai yang tercakup pada kebijakan keamanan Anda.

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

------

------
+ Sebuah cluster Kubernetes. [Untuk membuat cluster Amazon Elastic Kubernetes Service, lihat panduan mulai cepat Amazon EKS.](https://docs.aws.amazon.com/eks/latest/userguide/quickstart.html) Untuk mempermudah, buat variabel lingkungan untuk menampung nama cluster:

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

  
+  Wilayah AWS Tempat klaster CA dan Amazon EKS Anda berada. Untuk mempermudah, buat variabel lingkungan untuk menampung Wilayah:

  ```
  export REGION={{{{aws-region}}}}
  ```
+ Nama Sumber Daya Amazon (ARN) dari otoritas sertifikat AWS Private CA swasta. Untuk mempermudah, buat variabel lingkungan untuk menampung CA ARN pribadi:

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

  Untuk membuat CA pribadi, lihat [https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html](https://docs.aws.amazon.com/privateca/latest/userguide/create-CA.html) Buat CA pribadi di AWS Private CA
+ Komputer dengan perangkat lunak berikut diinstal:
  + [AWS CLI v2](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dikonfigurasi
  + [kubectl v1.13\+](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
  + [Untuk cluster EKS non-Amazon, Helm v3](https://helm.sh/docs/intro/install/)

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

Untuk menggunakan CA pribadi, Anda harus menginstal `cert-manager>` add-on yang meminta sertifikat, mendistribusikannya, dan mengotomatiskan perpanjangan sertifikat. Anda juga harus menginstal `aws-private-ca-issuer` plugin yang memungkinkan Anda mengeluarkan sertifikat pribadi dari AWS Private CA. Gunakan langkah-langkah berikut untuk menginstal add-on dan plugin.

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

Instal `cert-manager` sebagai add-on Amazon EKS:

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

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

Instal `cert-manager` menggunakan 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
```

------

## Mengonfigurasi izin IAM
<a name="kubernetes-iam-permissions"></a>

`aws-privateca-issuer`Plugin memerlukan izin berinteraksi dengan AWS Private CA. Untuk klaster Amazon EKS, Anda menggunakan identitas pod. Untuk cluster lain yang Anda gunakan AWS Identity and Access Management Roles Anywhere.

Tinju, buat kebijakan IAM. Kebijakan ini menggunakan kebijakan `AWSPrivateCAConnectorForKubernetesPolicy` terkelola. Untuk informasi selengkapnya tentang kebijakan ini, lihat [AWSPrivateCAConnectorForKubernetesPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSPrivateCAConnectorForKubernetesPolicy.html)di *Panduan referensi kebijakan AWS Terkelola*.

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

1. Buat file bernama `trust-policy.json` yang berisi kebijakan kepercayaan berikut:

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

****  

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

------

1. Jalankan perintah berikut untuk membuat peran 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. Buat jangkar kepercayaan yang mempercayai CA pribadi yang disimpan. `CA_ARN` Untuk instruksi, lihat [Memulai dengan IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html). Buat variabel lingkungan untuk menyimpan jangkar kepercayaan ARN:

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

1. Buat file bernama `trust-policy.json` berisi kebijakan kepercayaan berikut:

------
#### [ 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. Jalankan perintah berikut untuk membuat peran 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
   ```

------

## Instal dan konfigurasikan penerbit AWS Private CA cluster
<a name="kubernetes-install-aws-private-ca-cluster-issuer"></a>

Untuk menginstal `aws-privateca-connector-for-kubernetes` add-on, gunakan perintah berikut: 

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

Buat add-on:

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

Kemudian tunggu hingga add-on aktif:

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

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

1. Buat profil di 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. Buat sertifikat klien untuk digunakan dengan Konektor untuk Kubernetes dan untuk mengautentikasi IAM Roles Anywhere dengan: AWS Private CA

   1. Hasilkan kunci pribadi untuk sertifikat klien:

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

   1. Buat permintaan penandatanganan sertifikat (CSR) untuk sertifikat klien:

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

   1. Menerbitkan sertifikat klien dari 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. Simpan sertifikat klien secara lokal:

      ```
      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. Instal AWS Private CA penerbit di cluster dengan sertifikat klien:

   1. Tambahkan repositori Helm `awspca`:

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

   1. Buat namespace:

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

   1. Masukkan sertifikat yang dibuat sebelumnya ke dalam rahasia:

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

1. Instal AWS Private CA penerbit dengan IAM Roles Anywhere:

   1. Buat file bernama `values.yaml` untuk mengonfigurasi plugin AWS Private CA penerbit untuk digunakan dengan 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. Instal AWS Private CA penerbit dengan IAM Roles Anywhere:

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

------

Tunggu penerbit siap. Gunakan perintah berikut ini. 

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

Dan kemudian verifikasi instalasi untuk memastikan bahwa semua pod telah mencapai `READY` status:

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

Untuk mengonfigurasi`aws-private-ca-cluster-issuer`, buat file YAMB bernama `cluster-issuer.yaml` berisi konfigurasi penerbit:

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

Selanjutnya, terapkan konfigurasi cluster:

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

Periksa status penerbit:

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

Anda akan melihat respons yang mirip dengan berikut ini:

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

## Mengelola sertifikat AWS Private CA klien dengan cert-manager
<a name="kubernetes-manage-pca-certificate"></a>

Jika Anda tidak menggunakan kluster Amazon EKS, setelah Anda mem-bootstrap sertifikat tepercaya secara manual, `aws-privateca-issuer` Anda dapat beralih ke sertifikat otentikasi klien yang dikelola oleh`cert-manager`. Hal ini memungkinkan `cert-manager` untuk secara otomatis memperbarui sertifikat otentikasi klien.

1. Buat file bernama`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. Buat sertifikat otentikasi klien terkelola baru:

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

1. Validasi bahwa sertifikat telah dibuat:

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

   Anda akan melihat respons yang mirip dengan berikut ini:

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

## Terbitkan sertifikat TLS pertama Anda
<a name="kubernetes-issue-certificate"></a>

Sekarang setelah `cert-manager` dan `aws-privateca-issuer` diinstal, Anda dapat mengeluarkan sertifikat.

Buat file YAMM bernama `certificate.yaml` yang berisi sumber daya sertifikat:

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

Terapkan sertifikat menggunakan perintah berikut:

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

Anda kemudian dapat memeriksa status sertifikat dengan perintah berikut:

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

Anda akan melihat respons yang mirip dengan ini:

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

Anda dapat memeriksa sertifikat yang dikeluarkan dengan perintah berikut:

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

Anda juga dapat memecahkan kode dan memeriksa sertifikat dengan perintah berikut:

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