Automatisation de la gestion des certificats SSL Let's Encrypt en utilisant le DNS-01 challenge et AWS.

Cet article décrit les étapes pour automatiser la gestion des certificats SSL de Let’s Encrypt CA en utilisant défi DNS-01 et AWS.

acme-dns-route53 — est un outil qui nous permettra de réaliser cette fonctionnalité. Il peut travailler avec des certificats SSL de Let’s Encrypt, les enregistrer dans Amazon Certificate Manager, utiliser l’API Route53 pour réaliser le défi DNS-01, et, enfin, envoyer des notifications dans SNS. Dans acme-dns-route53 il y a également une fonctionnalité intégrée pour être utilisée à l’intérieur d’AWS Lambda, et c’est ce dont nous avons besoin.

Cet article est divisé en 4 sections :

• création d’un fichier zip ;
• création d’un rôle IAM ;
• création d’une fonction lambda qui lance acme-dns-route53;
• création d’un minuteur CloudWatch qui déclenche la fonction deux fois par jour ;

Note : avant de commencer, vous devez installer GoLang 1.9+ et CLI AWS

Création d’un fichier zip

acme-dns-route53 est écrit en GoLang et nécessite la version 1.9 ou supérieure.

Nous devons créer un fichier zip avec le binaire acme-dns-route53 à l’intérieur. Pour cela, il faut installer acme-dns-route53 à partir du dépôt GitHub en utilisant la commande go install:

$ env GOOS=linux GOARCH=amd64 go install github.com/begmaroman/acme-dns-route53

Le binaire sera installé dans $GOPATH/bin répertoire. Notez que lors de l’installation, nous avons spécifié deux variables d’environnement : GOOS=linux et GOARCH=amd64. Elles indiquent au compilateur Go qu’il doit créer un binaire adapté pour le système d’exploitation Linux et l’architecture amd64 — c’est ce qui s’exécute dans AWS.
AWS nécessite le déploiement de notre programme dans un fichier zip, alors créons acme-dns-route53.zip une archive qui contiendra le binaire nouvellement installé :

$ zip -j ~/acme-dns-route53.zip $GOPATH/bin/acme-dns-route53

Note : le binaire doit être à la racine de l’archive zip. Pour cela, nous utilisons -j le drapeau.

Maintenant, notre zip est prêt à être déployé, il ne reste plus qu’à créer un rôle avec les permissions nécessaires.

Création du rôle IAM

Nous devons configurer un rôle IAM avec les permissions nécessaires pour notre lambda pendant son exécution.
Appelons cette politique lambda-acme-dns-route53-executor et donnons-lui immédiatement un rôle de base AWSLambdaBasicExecutionRole. Cela permettra à notre lambda de démarrer et d’écrire des logs dans le service AWS CloudWatch.
Pour commencer, créons un fichier JSON décrivant nos permissions. Cela, en gros, autorisera les services lambda à utiliser le rôle lambda-acme-dns-route53-executor:

$ touch ~/lambda-acme-dns-route53-executor-policy.json

Le contenu de notre fichier est le suivant :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup"
            ],
            "Resource": "arn:aws:logs:::*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents",
                "logs:CreateLogStream"
            ],
            "Resource": "arn:aws:logs:::log-group:/aws/lambda/acme-dns-route53:*"
        },
        {
            "Sid": "",
            "Effect": "Allow",
            "Action": [
                "route53:ListHostedZones",
                "cloudwatch:PutMetricData",
                "acm:ImportCertificate",
                "acm:ListCertificates"
            ],
            "Resource": "*"
        },
        {
            "Sid": "",
            "Effect": "Allow",
            "Action": [
                "sns:Publish",
                "route53:GetChange",
                "route53:ChangeResourceRecordSets",
                "acm:ImportCertificate",
                "acm:DescribeCertificate"
            ],
            "Resource": [
                "arn:aws:sns:${var.region}::",
                "arn:aws:route53:::hostedzone/*",
                "arn:aws:route53:::change/*",
                "arn:aws:acm:::certificate/*"
            ]
        }
    ]
}

Maintenant exécutons la commande aws iam create-role pour créer un rôle :

$ aws iam create-role --role-name lambda-acme-dns-route53-executor 
 --assume-role-policy-document ~/lambda-acme-dns-route53-executor-policy.json

Note : n'oubliez pas le policy ARN (Amazon Resource Name) — nous en aurons besoin aux étapes suivantes.

Le rôle lambda-acme-dns-route53-executor est créé, maintenant nous devons spécifier des autorisations pour lui. Le moyen le plus simple de le faire est d'utiliser la commande aws iam attach-role-policy, en passant le policy ARN AWSLambdaBasicExecutionRole comme suit :

$ aws iam attach-role-policy --role-name lambda-acme-dns-route53-executor 
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole

Note : Une liste des autres politiques peut être trouvée ici.

Création d'une fonction lambda qui exécute acme-dns-route53

Youpi ! Nous pouvons maintenant déployer notre fonction sur AWS en utilisant la commande aws lambda create-function. La lambda doit être configurée en utilisant les variables d'environnement suivantes :

• AWS_LAMBDA — indique acme-dns-route53 que l'exécution se produit à l'intérieur d'AWS Lambda.
• DOMAINS — liste des domaines, séparés par des virgules.
• LETSENCRYPT_EMAIL — contient l'email Let's Encrypt.
• NOTIFICATION_TOPIC — le nom du sujet de notification SNS (optionnel).
• STAGING — lorsque sa valeur est 1 utilisé pour l'environnement de staging.
• 1024 MB — limite de mémoire, peut être modifiée.
• 900 secs (15 min) — délai d'attente.
• acme-dns-route53 — le nom de notre binaire, qui est dans l'archive.
• fileb://~/acme-dns-route53.zip — chemin vers l'archive que nous avons créée.

Nous déployons maintenant :

$ aws lambda create-function 
 --function-name acme-dns-route53 
 --runtime go1.x 
 --role arn:aws:iam:::role/lambda-acme-dns-route53-executor 
 --environment Variables="{AWS_LAMBDA=1,DOMAINS="example1.com,example2.com",LETSENCRYPT_EMAIL=begmaroman@gmail.com,STAGING=0,NOTIFICATION_TOPIC=acme-dns-route53-obtained}" 
 --memory-size 1024 
 --timeout 900 
 --handler acme-dns-route53 
 --zip-file fileb://~/acme-dns-route53.zip

 {
     "FunctionName": "acme-dns-route53", 
     "LastModified": "2019-05-03T19:07:09.325+0000", 
     "RevisionId": "e3fadec9-2180-4bff-bb9a-999b1b71a558", 
     "MemorySize": 1024, 
     "Environment": {
         "Variables": {
            "DOMAINS": "example1.com,example2.com", 
            "STAGING": "1", 
            "LETSENCRYPT_EMAIL": "your@email.com", 
            "NOTIFICATION_TOPIC": "acme-dns-route53-obtained", 
            "AWS_LAMBDA": "1"
         }
     }, 
     "Version": "$LATEST", 
     "Role": "arn:aws:iam:::role/lambda-acme-dns-route53-executor", 
     "Timeout": 900, 
     "Runtime": "go1.x", 
     "TracingConfig": {
         "Mode": "PassThrough"
     }, 
     "CodeSha256": "+2KgE5mh5LGaOsni36pdmPP9O35wgZ6TbddspyaIXXw=", 
     "Description": "", 
     "CodeSize": 8456317,
"FunctionArn": "arn:aws:lambda:us-east-1::function:acme-dns-route53", 
     "Handler": "acme-dns-route53"
 }

Création d'un minuteur CloudWatch qui déclenche la fonction deux fois par jour

La dernière étape consiste à configurer un cron qui appelle notre fonction deux fois par jour :

• créer une règle CloudWatch avec la valeur schedule_expression.
• créer une cible de règle (ce qui doit être exécuté), en spécifiant l'ARN de la fonction lambda.
• donner la permission à la règle d'appeler la fonction lambda.

Ci-dessous, j'ai joint ma configuration Terraform, mais en réalité, cela se fait très facilement via la console AWS ou AWS CLI.

# Cloudwatch event rule that runs acme-dns-route53 lambda every 12 hours
resource "aws_cloudwatch_event_rule" "acme_dns_route53_sheduler" {
  name                = "acme-dns-route53-issuer-scheduler"
  schedule_expression = "cron(0 */12 * * ? *)"
}

# Specify the lambda function to run
resource "aws_cloudwatch_event_target" "acme_dns_route53_sheduler_target" {
  rule = "${aws_cloudwatch_event_rule.acme_dns_route53_sheduler.name}"
  arn  = "${aws_lambda_function.acme_dns_route53.arn}"
}

# Give CloudWatch permission to invoke the function
resource "aws_lambda_permission" "permission" {
  action        = "lambda:InvokeFunction"
  function_name = "${aws_lambda_function.acme_dns_route53.function_name}"
  principal     = "events.amazonaws.com"
  source_arn    = "${aws_cloudwatch_event_rule.acme_dns_route53_sheduler.arn}"
}

Vous avez maintenant configuré la création et la mise à jour automatiques des certificats SSL.

Source : habr.com