Simplificación de la autenticación de aplicaciones con TLS mutuo en Amazon ECS mediante el equilibrador de carga de aplicación

Descargue el código fuente.

Para descargar el código fuente de este patrón, bifurque o clone el repositorio MTLS-with-Application-Load-Balancer-in-Amazon-ECS de GitHub.

Cree un repositorio de Git.

Para crear un repositorio de Git que contenga el Dockerfile y los archivos buildspec.yaml, haga lo siguiente:

git clone https://github.com/aws-samples/mTLS-with-Application-Load-Balancer-in-Amazon-ECS.git

Cree una CA privada en AWS Private CA.

Para crear una autoridad de certificación (CA) privada, ejecute los siguientes comandos en su terminal. Sustituya los valores de las variables de ejemplo por sus propios valores.

export AWS_DEFAULT_REGION="us-west-2"
export SERVICES_DOMAIN="www.example.com"

export ROOT_CA_ARN=`aws acm-pca create-certificate-authority \
    --certificate-authority-type ROOT \
    --certificate-authority-configuration \
    "KeyAlgorithm=RSA_2048,
    SigningAlgorithm=SHA256WITHRSA,
    Subject={
        Country=US,
        State=WA,
        Locality=Seattle,
        Organization=Build on AWS,
        OrganizationalUnit=mTLS Amazon ECS and ALB Example,
        CommonName=${SERVICES_DOMAIN}}" \
        --query CertificateAuthorityArn --output text`

Para más información, consulte Create a private CA in AWS Private CA en la documentación de AWS.

Cree e instale su certificado CA privado.

Para crear e instalar un certificado para su CA raíz privada, ejecute los comandos siguientes en su terminal:

Solicite un certificado administrado.

Para solicitar un certificado privado en AWS Certificate Manager para utilizarlo con su ALB privado, utilice el comando siguiente:

export TLS_CERTIFICATE_ARN=`aws acm request-certificate \
    --domain-name "*.${DOMAIN_DOMAIN}" \
    --certificate-authority-arn ${ROOT_CA_ARN} \
    --query CertificateArn --output text`

Utilice la CA privada para emitir un certificado de cliente.

openssl req -out client_csr1.pem -new -newkey rsa:2048 -nodes -keyout client_private-key1.pem

openssl req -out client_csr2.pem -new -newkey rsa:2048 -nodes -keyout client_private-key2.pem

Este comando devuelve la CSR y la clave privada de los dos servicios.

SERVICE_ONE_CERT_ARN=`aws acm-pca issue-certificate \
    --certificate-authority-arn ${ROOT_CA_ARN} \
    --csr fileb://client_csr1.pem \
    --signing-algorithm "SHA256WITHRSA" \
    --validity Value=5,Type="YEARS" --query CertificateArn --output text` 

echo "SERVICE_ONE_CERT_ARN: ${SERVICE_ONE_CERT_ARN}"

aws acm-pca get-certificate \
    --certificate-authority-arn ${ROOT_CA_ARN} \
    --certificate-arn ${SERVICE_ONE_CERT_ARN} \
     | jq -r '.Certificate' > client_cert1.cert

SERVICE_TWO_CERT_ARN=`aws acm-pca issue-certificate \
    --certificate-authority-arn ${ROOT_CA_ARN} \
    --csr fileb://client_csr2.pem \
    --signing-algorithm "SHA256WITHRSA" \
    --validity Value=5,Type="YEARS" --query CertificateArn --output text` 

echo "SERVICE_TWO_CERT_ARN: ${SERVICE_TWO_CERT_ARN}"

aws acm-pca get-certificate \
    --certificate-authority-arn ${ROOT_CA_ARN} \
    --certificate-arn ${SERVICE_TWO_CERT_ARN} \
     | jq -r '.Certificate' > client_cert2.cert

Para más información, consulte Issue private end-entity certificates en la documentación de AWS.

Aprovisione Servicios de AWS con la plantilla de CloudFormation.

Para aprovisionar la nube privada virtual (VPC), el clúster de Amazon ECS, los servicios de Amazon ECS, el Equilibrador de carga de aplicación y Amazon Elastic Container Registry (Amazon ECR), utilice la plantilla de CloudFormation.

Obtenga las variables.

Verifique que tiene un clúster de Amazon ECS con dos servicios en ejecución. Para recuperar los detalles del recurso y almacenarlos como variables, utilice los comandos siguientes:

export LoadBalancerDNS=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`LoadBalancerDNS`].OutputValue')

export ECRRepositoryUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryUri`].OutputValue')

export ECRRepositoryServiceOneUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryServiceOneUri`].OutputValue')

export ECRRepositoryServiceTwoUri=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ECRRepositoryServiceTwoUri`].OutputValue')

export ClusterName=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`ClusterName`].OutputValue')

export BucketName=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`BucketName`].OutputValue')

export Service1ListenerArn=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`Service1ListenerArn`].OutputValue')

export Service2ListenerArn=$(aws cloudformation describe-stacks --stack-name ecs-mtls \
--output text \
--query 'Stacks[0].Outputs[?OutputKey==`Service2ListenerArn`].OutputValue')

Cree un proyecto de CodeBuild.

Para utilizar un proyecto de CodeBuild para crear las imágenes de Docker para los servicios de Amazon ECS, haga lo siguiente:

Para más información, consulte Create a build project in AWS CodeBuild en la documentación de AWS.

Cree las imágenes de Docker.

Puede usar CodeBuild para llevar a cabo el proceso de creación de imágenes. CodeBuild necesita permisos para interactuar con Amazon ECR y trabajar con Amazon S3.

Como parte del proceso, la imagen de Docker se compila y envía al registro de Amazon ECR. Para obtener información sobre la plantilla y el código, consulte Información adicional.

(Opcional) Para compilar localmente con fines de prueba, utilice el siguiente comando:

# login to ECR
aws ecr get-login-password | docker login --username AWS --password-stdin $ECRRepositoryUri

# build image for service one
cd /service1
aws s3 cp s3://$BucketName/serviceone/ service1/ --recursive
docker build -t $ECRRepositoryServiceOneUri .
docker push $ECRRepositoryServiceOneUri

# build image for service two
cd ../service2
aws s3 cp s3://$BucketName/servicetwo/ service2/ --recursive
docker build -t $ECRRepositoryServiceTwoUri .
docker push $ECRRepositoryServiceTwoUri

Cargue el certificado CA en Amazon S3.

Para cargar el certificado CA en el bucket de Amazon S3, utilice el comando de ejemplo siguiente:

aws s3 cp ca-cert.pem s3://$BucketName/acm-trust-store/

Cree un almacén de confianza.

Para crear el almacén de confianza, utilice el comando de ejemplo siguiente:

TrustStoreArn=`aws elbv2 create-trust-store --name acm-pca-trust-certs \
    --ca-certificates-bundle-s3-bucket $BucketName \
    --ca-certificates-bundle-s3-key acm-trust-store/ca-cert.pem --query 'TrustStores[].TrustStoreArn' --output text`

Cargue los certificados de cliente.

Para cargar los certificados de cliente en Amazon S3 para las imágenes de Docker, utilice el comando de ejemplo siguiente:

# for service one
aws s3 cp client_cert1.cert s3://$BucketName/serviceone/
aws s3 cp client_private-key1.pem s3://$BucketName/serviceone/

# for service two
aws s3 cp client_cert2.cert s3://$BucketName/servicetwo/
aws s3 cp client_private-key2.pem s3://$BucketName/servicetwo/

Modifique el oyente.

Para habilitar el TLS mutuo en el ALB, modifique los oyentes HTTPS con los comandos siguientes:

aws elbv2 modify-listener \
    --listener-arn $Service1ListenerArn \
    --certificates CertificateArn=$TLS_CERTIFICATE_ARN_TWO \
    --ssl-policy ELBSecurityPolicy-2016-08 \
    --protocol HTTPS \
    --port 8080 \
    --mutual-authentication Mode=verify,TrustStoreArn=$TrustStoreArn,IgnoreClientCertificateExpiry=false

aws elbv2 modify-listener \
    --listener-arn $Service2ListenerArn \
    --certificates CertificateArn=$TLS_CERTIFICATE_ARN_TWO \
    --ssl-policy ELBSecurityPolicy-2016-08 \
    --protocol HTTPS \
    --port 8090 \
    --mutual-authentication Mode=verify,TrustStoreArn=$TrustStoreArn,IgnoreClientCertificateExpiry=false

Para más información, consulte Configuring mutual TLS on an Application Load Balancer en la documentación de AWS.

Actualice la definición de tareas de Amazon ECS.

Para actualizar la definición de tareas de Amazon ECS, modifique el parámetro image en la revisión nueva.

Para obtener los valores de los servicios respectivos, actualice las definiciones de tareas con la nueva URI de imágenes de Docker que creó en los pasos anteriores: echo $ECRRepositoryServiceOneUri o echo $ECRRepositoryServiceTwoUri

    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/nginx/nginx:latest",   # <----- change to new Uri
            "cpu": 0,

Para más información, consulte Actualización de una definición de tareas de Amazon ECS mediante la consola en la documentación de AWS.

Actualice el servicio Amazon ECS.

Actualice el servicio con la última definición de tareas. Esta definición de tareas es el esquema de las imágenes de Docker recién creadas y contiene el certificado de cliente que se requiere para la autenticación de TLS mutua.

Para actualizar el servicio, proceda de la manera siguiente:

Repita los pasos para el otro servicio.

Copie la URL de la aplicación.

Utilice la consola de Amazon ECS para ver la tarea. Cuando el estado de la tarea se haya actualizado a En ejecución, seleccione la tarea. En la sección Tarea, copie el ID de la tarea.

Pruebe su aplicación.

Para probar la aplicación, utilice ECS Exec para acceder a las tareas.