Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Proteja las cargas de trabajo de Kubernetes con certificados ACM
Puede usar certificados públicos AWS Certificate Manager exportables con AWS Controllers for Kubernetes (ACK) para emitir y exportar certificados TLS públicos desde ACM a sus cargas de trabajo de Kubernetes. Esta integración le permite proteger los pods de Amazon Elastic Kubernetes Service (Amazon EKS) y cancelar el TLS en su entrada de Kubernetes. [Para empezar, consulte el ACM Controller para Kubernetes en.](https://github.com/aws-controllers-k8s/acm-controller) GitHub
AWS Controllers for Kubernetes (ACK) amplía la API de Kubernetes para gestionar los recursos mediante manifiestos nativos de Kubernetes. AWS El controlador de servicios ACK para ACM proporciona una gestión automatizada del ciclo de vida de los certificados dentro del flujo de trabajo de Kubernetes. Al crear un recurso de certificado ACM en Kubernetes, el controlador ACK realiza las siguientes acciones:
1. Solicita un certificado a ACM, que genera la solicitud de firma de certificado (CSR).
1. Espera a que se complete la validación del dominio y a que ACM emita el certificado.
1. Si se especifica el `exportTo` campo, exporta el certificado emitido y la clave privada y los almacena en el Kubernetes Secret especificado.
1. Si se especifica el `exportTo` campo y el certificado puede renovarse, actualiza el secreto de Kubernetes con los certificados renovados antes de que caduquen.
Los certificados emitidos públicamente requieren la [validación del dominio](https://docs.aws.amazon.com//acm/latest/userguide/dns-validation.html) antes de que ACM pueda emitirlos. Puede usar el [controlador de servicio ACK para Amazon Route 53](https://github.com/aws-controllers-k8s/route53-controller) para crear automáticamente los registros CNAME de validación de DNS necesarios en la zona alojada.
## Opciones de uso de certificados
Puedes usar los certificados ACM con Kubernetes de varias maneras:
1. *Terminación del balanceador de carga (sin exportación)*: emita certificados a través de ACK y utilícelos para terminar el TLS en un balanceador de carga. AWS El certificado permanece en ACM y el controlador del [AWS Load Balancer](https://kubernetes-sigs.github.io/aws-load-balancer-controller/v2.1/guide/ingress/cert_discovery/) lo detecta automáticamente. Este enfoque no requiere la exportación del certificado.
1. *Terminación de ingreso (con exportación)*: exporte los certificados de ACM y guárdelos en Kubernetes Secrets para su terminación mediante TLS a nivel de ingreso. Esto le permite usar los certificados directamente en sus cargas de trabajo de Kubernetes.
**nota**
Para ver los casos de uso que requieren certificados privados, consulte [AWS Private CA Connector for Kubernetes](https://docs.aws.amazon.com//privateca/latest/userguide/PcaKubernetes-concepts.html), un complemento de administración de certificados.
## Requisitos previos
Antes de instalar el controlador de servicio ACK para ACM, asegúrese de tener lo siguiente:
+ Un clúster de Kubernetes.
+ Helm instalado.
+ `kubectl` configurado para comunicarse con el clúster.
+ `eksctl`instalado para configurar las asociaciones de identidad de los pods en EKS.
## Instale el controlador de servicio ACK para ACM
Utilice Helm para instalar el controlador de servicio ACK para ACM en su clúster de Amazon EKS.
1. Cree un espacio de nombres para el controlador ACK.
```
$ kubectl create namespace ack-system --dry-run=client -o yaml | kubectl apply -f -
```
1. Cree una asociación de identidad de módulo para el controlador ACK. {{CLUSTER\_NAME}}Sustitúyala por el nombre de tu clúster y {{REGION}} por tu AWS región.
```
$ 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. Inicie sesión en el registro público de Amazon ECR.
```
$ aws ecr-public get-login-password --region us-east-1 | helm registry login --username AWS --password-stdin public.ecr.aws
```
1. Instale el controlador de servicio ACK para ACM. {{REGION}}Sustitúyalo por su AWS región.
```
$ 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. Compruebe que la controladora esté funcionando.
```
$ kubectl get pods -n ack-system
```
Para obtener más información sobre las asociaciones de identidad de pods, consulte [EKS Pod Identity](https://docs.aws.amazon.com//eks/latest/userguide/pod-identities.html) en la *Guía del usuario de Amazon EKS*.
## Ejemplo: Termine el TLS en la entrada
El siguiente ejemplo muestra cómo exportar un certificado ACM y usarlo para terminar el TLS en el nivel de entrada de Kubernetes. Esta configuración crea un certificado ACM, lo exporta a un Kubernetes Secret y configura un recurso de Ingress para usar el certificado para la terminación de TLS.
En este ejemplo:
+ El secreto se crea para almacenar el certificado exportado () `exported-cert-secret`
+ El recurso de certificado ACK solicita un certificado de ACM para su dominio y lo exporta al `exported-cert-secret` secreto.
+ El recurso Ingress hace referencia al TLS `exported-cert-secret` de terminación para el tráfico entrante.
Sustituya `${HOSTNAME}` por su nombre de dominio.
```
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
```
Una vez implementado, el controlador de servicios ACK para ACM administra automáticamente el ciclo de vida del certificado, incluidas las renovaciones. Cuando ACM renueva el certificado, el controlador actualiza el `exported-cert-secret` secreto con el nuevo certificado, lo que garantiza que Ingress siga utilizando certificados válidos sin intervención manual.