As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Proteja cargas de trabalho do Kubernetes com certificados ACM
Você pode usar certificados públicos AWS Certificate Manager exportáveis com AWS Controllers for Kubernetes (ACK) para emitir e exportar certificados TLS públicos do ACM para suas cargas de trabalho do Kubernetes. Essa integração permite que você proteja os pods do Amazon Elastic Kubernetes Service (Amazon EKS) e encerre o TLS no seu Kubernetes Ingress. Para começar, consulte o [Controlador ACM para Kubernetes ativado](https://github.com/aws-controllers-k8s/acm-controller). GitHub
AWS Os controladores para Kubernetes (ACK) estendem a API Kubernetes para gerenciar recursos usando manifestos nativos do Kubernetes. AWS O controlador de serviço ACK para ACM fornece gerenciamento automatizado do ciclo de vida do certificado em seu fluxo de trabalho do Kubernetes. Quando você cria um recurso de certificado ACM no Kubernetes, o controlador ACK executa as seguintes ações:
1. Solicita um certificado do ACM, que gera a solicitação de assinatura de certificado (CSR).
1. Aguarda a conclusão da validação do domínio e a emissão do certificado pelo ACM.
1. Se o `exportTo` campo for especificado, exporta o certificado emitido e a chave privada e os armazena no segredo do Kubernetes especificado.
1. Se o `exportTo` campo for especificado e o certificado estiver qualificado para renovação, atualize o segredo do Kubernetes com certificados renovados antes da expiração.
Os certificados emitidos publicamente exigem a [validação do domínio](https://docs.aws.amazon.com//acm/latest/userguide/dns-validation.html) antes que o ACM possa emiti-los. Você pode usar o [controlador de serviço ACK para o Amazon Route 53](https://github.com/aws-controllers-k8s/route53-controller) para criar automaticamente os registros CNAME de validação de DNS necessários na sua zona hospedada.
## Opções de uso do certificado
Você pode usar certificados ACM com o Kubernetes de algumas maneiras:
1. Encerramento do *balanceador de carga (sem exportação)*: emita certificados por meio do ACK e use-os para encerrar o TLS em um AWS balanceador de carga. O certificado permanece no ACM e é descoberto automaticamente pelo Load [AWS Balancer Controller](https://kubernetes-sigs.github.io/aws-load-balancer-controller/v2.1/guide/ingress/cert_discovery/). Essa abordagem não exige a exportação do certificado.
1. *Encerramento de entrada (com exportação): exporte certificados do ACM e armazene-os no Kubernetes Secrets para terminação* de TLS no nível de entrada. Isso permite que você use certificados diretamente em suas cargas de trabalho do Kubernetes.
**nota**
Para casos de uso que exigem certificados privados, consulte [AWS Private CA Connector for Kubernetes](https://docs.aws.amazon.com//privateca/latest/userguide/PcaKubernetes-concepts.html), um plug-in cert-manager.
## Pré-requisitos
Antes de instalar o controlador de serviço ACK para ACM, verifique se você tem o seguinte:
+ Um cluster Kubernetes.
+ Capacete instalado.
+ O `kubectl` configurado para se comunicar com o cluster.
+ `eksctl`instalado para configurar associações de identidade de pod no EKS.
## Instale o controlador de serviço ACK para ACM
Use o Helm para instalar o controlador de serviço ACK para ACM em seu cluster Amazon EKS.
1. Crie um namespace para o controlador ACK.
```
$ kubectl create namespace ack-system --dry-run=client -o yaml | kubectl apply -f -
```
1. Crie uma associação de identidade de pod para o controlador ACK. {{CLUSTER\_NAME}}Substitua pelo nome do seu cluster e {{REGION}} pela sua AWS região.
```
$ eksctl create podidentityassociation --cluster {{CLUSTER_NAME}} --region {{REGION}} \
--namespace ack-system \
--create-service-account \
--service-account-name ack-acm-controller \
--permission-policy-arns arn:aws:iam::aws:policy/AWSCertificateManagerFullAccess
```
1. Faça login no registro público do Amazon ECR.
```
$ aws ecr-public get-login-password --region us-east-1 | helm registry login --username AWS --password-stdin public.ecr.aws
```
1. Instale o controlador de serviço ACK para ACM. {{REGION}}Substitua pela sua AWS região.
```
$ helm install -n ack-system ack-acm-controller oci://public.ecr.aws/aws-controllers-k8s/acm-chart --set serviceAccount.create=false --set serviceAccount.name=ack-acm-controller --set aws.region={{REGION}}
```
1. Verifique se o controlador está em execução.
```
$ kubectl get pods -n ack-system
```
Para obter mais informações sobre associações de identidade de pod, consulte [EKS Pod Identity](https://docs.aws.amazon.com//eks/latest/userguide/pod-identities.html) no *Guia do usuário do Amazon EKS*.
## Exemplo: Encerrar o TLS no Ingress
O exemplo a seguir demonstra como exportar um certificado ACM e usá-lo para encerrar o TLS no nível do Kubernetes Ingress. Essa configuração cria um certificado ACM, o exporta para um segredo do Kubernetes e configura um recurso de entrada para usar o certificado para terminação de TLS.
Neste exemplo:
+ O segredo é criado para armazenar o certificado exportado () `exported-cert-secret`
+ O recurso ACK Certificate solicita um certificado do ACM para seu domínio e o exporta para o `exported-cert-secret` Secret.
+ O recurso Ingress faz referência `exported-cert-secret` ao para encerrar o TLS para tráfego de entrada.
Substitua `${HOSTNAME}` pelo nome do domínio.
```
apiVersion: v1
kind: Secret
type: kubernetes.io/tls
metadata:
name: exported-cert-secret
namespace: demo-app
data:
tls.crt: ""
tls.key: ""
---
apiVersion: acm.services.k8s.aws/v1alpha1
kind: Certificate
metadata:
name: exportable-public-cert
namespace: demo-app
spec:
domainName: ${HOSTNAME}
options:
certificateTransparencyLoggingPreference: ENABLED
exportTo:
namespace: demo-app
name: exported-cert-secret
key: tls.crt
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ingress-traefik
namespace: demo-app
spec:
tls:
- hosts:
- ${HOSTNAME}
secretName: exported-cert-secret
ingressClassName: traefik
rules:
- host: ${HOSTNAME}
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: whoami
port:
number: 80
```
Depois de implantado, o controlador de serviço ACK para ACM gerencia automaticamente o ciclo de vida do certificado, incluindo renovações. Quando o ACM renova o certificado, o controlador atualiza o `exported-cert-secret` segredo com o novo certificado, garantindo que seu Ingress continue usando certificados válidos sem intervenção manual.