Autenticação simplificada de aplicações com TLS mútua no Amazon ECS usando o Application Load Balancer

Faça o download do código-fonte.

Para baixar o código-fonte desse padrão, bifurque ou clone o repositório mTLS-with-Application-Load-Balancer-in-Amazon-ECS do GitHub.

Crie um repositório Git.

Para criar um repositório Git para conter o Dockerfile e os arquivos buildspec.yaml, siga as etapas abaixo:

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

Crie uma CA privada no CA Privada da AWS.

Para criar uma autoridade de certificação (CA) privada, execute os comandos a seguir no seu terminal. Substitua os valores no exemplo por seus próprios 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 obter mais detalhes, consulte Create a private CA in CA Privada da AWS na documentação da AWS.

Crie e instale seu certificado CA privado.

Para criar e instalar um certificado para sua CA raiz privada, execute os comandos os seguintes no seu terminal:

Solicite um certificado gerenciado.

Para solicitar um certificado privado no AWS Certificate Manager para usar com seu ALB privado, use o seguinte comando:

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

Use a CA privada para emitir um 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

Esse comando retorna a CSR e a chave privada dos dois serviços.

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 obter mais informações, consulte Issue private end-entity certificates na documentação da AWS.

Provisione os Serviços da AWS com o modelo do CloudFormation.

Para provisionar a nuvem privada virtual (VPC), o cluster do Amazon ECS, os serviços do Amazon ECS, o Application Load Balancer e o Amazon Elastic Container Registry (Amazon ECR), use o modelo do CloudFormation.

Obtenha as variáveis.

Verifique se você tem um cluster do Amazon ECS com dois serviços em execução. Para recuperar os detalhes do recurso e armazená-los como variáveis, use os seguintes comandos:

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')

Criar um projeto do CodeBuild.

Para usar um projeto do CodeBuild para criar as imagens do Docker dos seus serviços do Amazon ECS, faça o seguinte:

Para obter mais detalhes, consulte Create a build project in AWS CodeBuild na documentação da AWS.

Crie as imagens do Docker.

Você pode usar o CodeBuild para realizar o processo de criação de imagens. O CodeBuild precisa de permissões para interagir com o Amazon ECR e trabalhar com o Amazon S3.

Como parte do processo, a imagem do Docker é criada e enviada para o registro do Amazon ECR. Para obter detalhes sobre o modelo e o código, consulte Informações adicionais.

(Opcional) Para criar as imagens localmente para fins de teste, use o seguinte 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

Faça o upload do certificado CA para o Amazon S3.

Para fazer o upload do certificado CA para o bucket do Amazon S3, use o seguinte exemplo de comando:

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

Crie o armazenamento confiável.

Para criar o armazenamento confiável, use o seguinte exemplo de comando:

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`

Faça o upload dos certificados de cliente.

Para fazer upload dos certificados de cliente ao Amazon S3 para imagens do Docker, use o seguinte exemplo de comando:

# 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 o receptor.

Para habilitar a TLS mútua no ALB, modifique os receptores HTTPS usando os seguintes comandos:

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 obter mais informações, consulte Configuring mutual TLS on an Application Load Balancer na documentação da AWS.

Atualize a definição de tarefa do Amazon ECS.

Para atualizar a definição da tarefa do Amazon ECS, modifique o parâmetro image na nova revisão.

Para obter os valores dos respectivos serviços, atualize as definições de tarefas com o novo Uri de imagens do Docker que você criou nas etapas anteriores: echo $ECRRepositoryServiceOneUri ou echo $ECRRepositoryServiceTwoUri

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

Para obter mais informações, consulte Atualizar uma definição de tarefa do Amazon ECS usando o console na documentação da AWS.

Atualize o serviço do Amazon ECS.

Atualize o serviço com a definição de tarefa mais recente. Essa definição de tarefa é o esquema para as imagens do Docker criadas recentemente e contém o certificado de cliente necessário para a autenticação de TLS mútua.

Para atualizar o serviço, use o seguinte procedimento:

Repita as etapas para o outro serviço.

Copie o URL do aplicativo.

Use o console do Amazon ECS para visualizar a tarefa. Quando o status da tarefa for atualizado para Em execução, selecione a tarefa. Na seção Tarefa, copie o ID da tarefa.

Testar seu aplicativo

Para testar sua aplicação, use o ECS Exec para acessar as tarefas.