• 10 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 20/05/2019

Automatisez vos systèmes cloud

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Vous avez découvert pas à pas comment fonctionnaient les groupes de mise à l’échelle et les équilibreurs de charge dans AWS. Dans un contexte métier, vous auriez directement réalisé les étapes de création avec CloudFormation.

Dans le contexte de ce cours, vous avez d’abord appris à utiliser la console web d’AWS, afin que vous puissiez avoir un aperçu visuel de ce qu’il se passe étape par étape.  Nous allons à présent refaire tout cela, cette fois-ci avec CloudFormation.

Clean up !

Pour commencer, détruisez les ressources que vous avez créées précédemment, sauf la sauvegarde du disque, l’image AMI et la base de données, car cette dernière contient les tables de DotClear que nous souhaitons conserver. Tout le reste de l’infrastructure sera en revanche créé avec CloudFormation. Il vous faut donc détruire :

  • le groupe de mise à l’échelle ;

  • les deux Launch Configuration qu’on a créés ;

  • le Target Group ;

  • le Load Balancer ;

  • les groupes de sécurité qu’on a créés ;

  • si elle tourne toujours, la machine EC2 du site web.

Nous allons à présent créer une stack dans CloudFormation, c’est-à-dire une liste de ressources créées de manière automatique à partir des instructions d’un fichier appelé template.

Créez votre première stack

Dans la première partie, beaucoup d’éléments ont été créés en automatique en cliquant sur Next. Avec CloudFormation, il faut tous les créer explicitement. Vous allez en particulier commencer par créer un Security Group à associer à notre Load Balancer.

Allez dans le service CloudFormation et cliquez sur Create Stack. Comme dans la partie précédente, sélectionnez "Template is ready" et uploadez le template suivant :


AWSTemplateFormatVersion:  2010-09-09
Description:  >-
  AWS CloudFormation infrastructure Template
Resources: 
  WebsiteEC2SecurityGroup: 
    Type:  AWS::EC2::SecurityGroup
    Properties:
      GroupDescription:  Website EC2 security group 
      SecurityGroupEgress: 
        - IpProtocol:  -1
          CidrIp:  0.0.0.0/0
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      VpcId: vpc-xxx

Ce template crée un Security Group ouvrant le port 80 à toutes les IPv4 du monde (0.0.0.0/0). Remplacez la valeur de vpc-xxx par l’identifiant de VPC créé à l’étape précédente.

Tant qu’à faire, le nom du VPC peut être un paramètre de notre stack. Comme dans la partie précédente, rajoutez un paramètre comme ceci :

AWSTemplateFormatVersion:  2010-09-09
Description:  >-
  AWS CloudFormation infrastructure Template
Parameters: 
  VpcIdentifier:
    Type:  String
    Description: The target VPC identifier.
Resources:
  WebsiteEC2SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties: 
      GroupDescription: Website EC2 security group 
      SecurityGroupEgress: 
        - IpProtocol: -1
          CidrIp: 0.0.0.0/0
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      VpcId: !Ref VpcIdentifier

Pour que notre futur Load Balancer puisse diriger du trafic vers des instances, elles doivent exister dans un Auto Scaling Group. Pour que ce groupe puisse posséder des machines, nous devons renseigner une Launch Configuration. Vous allez par conséquent créer la Launch Configuration avec CloudFormation.

Créez les Launch Configuration avec CloudFormation

On ajoute le code suivant qui crée notre Launch Configuration, et pour bien faire, l’identifiant de l’AMI est en paramètre de notre stack.

WebsiteLaunchConfig: 
    Type: AWS::AutoScaling::LaunchConfiguration
    Properties:
      AssociatePublicIpAddress:false
      ImageId: !Ref AmiIdentifier
      InstanceType: t2.micro
      SecurityGroups:
        - !Ref WebsiteEC2SecurityGroup

Essayez de mettre à jour la stack existante avec ce nouveau template. Pour cela, récupérez le numéro de l’AMI dans le service EC2 comme ci-dessous, afin de le renseigner en variable de la stack.

 

Vous constatez qu’ici nous n’avons pas associé de paire de clés à la configuration ; cela signifie que les machines démarreront sans clé SSH associée ! Si nous voulions accéder aux machines, il faudrait renseigner une clé publique. Ici, la machine est autonome et préinstallée ; par conséquent nous n’avons pas besoin de renseigner de clé. Nous n’aurons pas du tout accès à la machine, et cela nous obligera à passer par des mécanismes de maintenance automatisés, c’est ce qu’on appelle l’infrastructure immutable.

Auparavant, nous avions dû ajouter un élément au démarrage des machines, appelé UserData, et faire une copie de notre configuration pour la modifier. L’avantage, à présent que nous sommes en pleine automatisation, est que CloudFormation va gérer à notre place la suppression et le remplacement du Launch Configuration sans qu’on ait à le dupliquer nous-mêmes. Voici le contenu du template mis à jour :

 WebsiteLaunchConfig:
    Type: AWS::AutoScaling::LaunchConfiguration
    Properties: 
      AssociatePublicIpAddress:  false
      ImageId: !Ref AmiIdentifier
      InstanceType: t2.micro
      SecurityGroups:
        - !Ref WebsiteEC2SecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash
          sudo systemctl start httpd

Hey, c’est quoi ce truc Fn::Base64:  !Sub | ? 

Il s’agit ici d’une astuce de syntaxe. On convertit le contenu à envoyer à UserData en base64, et on écrit le résultat sur plusieurs lignes. Voici en détail les différentes fonctions :

  • Fn::Base64 encode un élément en entrée en base64 ;

  • Fn::Sub permet de concaténer des chaînes de caractère en y injectant des variables. Ici, comme nous n’avons aucune variable à ajouter, nous aurions aussi pu utiliser Fn::Join.

Fn::Sub est indiqué dans le template sous la forme abrégée !Sub. La forme abrégée permet de gagner du temps à l’écriture.

Pourquoi ne pas utiliser la forme abrégée de Fn::Base64 ?

Il s’agit d’une limitation documentée par AWS. Vous ne pouvez pas imbriquer ces deux éléments dans leur forme abrégée. Vous devez avoir au moins une des deux fonctions écrite dans sa forme complète.

Nous allons à présent ajouter le groupe de mise à l’échelle et enfin l’équilibreur de charge.

Créez un Auto Scaling Group avec CloudFormation

Pour créer un groupe de mise à l’échelle automatique, il suffit de suivre la documentation. Nous devons référencer la Launch Configuration et spécifier les zones de disponibilité.

Vous aviez rencontré Fn::Select qui permet de choisir un élément dans une liste, nous allons utiliser Fn::GetAZs pour récupérer automatiquement la liste des zones de disponibilité d’une région, et !Ref AWS::Region pour récupérer le nom de la région dans laquelle s’exécute la stack.

Le code de votre template est à enrichir avec :

 WebsiteScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      LaunchConfigurationName: !Ref WebsiteLaunchConfig
      AvailabilityZones:
        - Fn::Select:
          - 0
          - Fn::GetAZs: !Ref AWS::Region
        - Fn::Select:
          - 1
          - Fn::GetAZs: !Ref AWS::Region
      VPCZoneIdentifier: !Ref PublicSubnets
      DesiredCapacity: 1
      MaxSize: 1
      MinSize: 1

Nous n’avons pas spécifié de Target Group pour ce groupe de mise à l’échelle ; c’est le moment de créer un Target Group pour notre futur Load Balancer et de l’associer au groupe de mise à l’échelle.

Créez les Target Group avec CloudFormation

Pour créer un Target Group, c’est relativement simple, basique :

 WebsiteTargetGroup: 
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties: 
      Port: 80
      Protocol: HTTP
      VpcId: !Ref VpcIdentifier

Nous pouvons à présent modifier notre Auto Scaling Group pour spécifier le Target Group comme ceci :

 WebsiteScalingGroup: 
    Type:AWS::AutoScaling::AutoScalingGroup
    Properties:
      LaunchConfigurationName: !Ref WebsiteLaunchConfig
      AvailabilityZones:
        - Fn::Select:
          - 0
          - Fn::GetAZs: !Ref AWS::Region
        - Fn::Select:
          - 1
          - Fn::GetAZs: !Ref AWS::Region
      VPCZoneIdentifier: !Ref PublicSubnets
      DesiredCapacity: 1
      MaxSize: 1
      MinSize: 1
      TargetGroupARNs: 
        - !Ref WebsiteTargetGroup

Allez courage, vous avez presque fini ! Il ne reste plus qu’à brancher un Load Balancer par-dessus et le tour sera joué. On ajoute un Security Group pour ouvrir le trafic et on écrit : 

WebsiteLoadBalancer: 
    Type:AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Type: application
      Scheme:internet-facing
      SecurityGroups:
        - !Ref WebsiteLoadBalancerSecurityGroup
      Subnets:  !Ref PublicSubnets
  WebsiteLoadBalancerSecurityGroup:
    Type:AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Website EC2 security group 
      SecurityGroupEgress:
        - IpProtocol: -1
          CidrIp: 0.0.0.0/0
      SecurityGroupIngress: 
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      VpcId: !Ref VpcIdentifier

 Enfin, nous allons devoir ajouter un Listener. C’est la première fois que vous en entendez parler, car il a été créé tout seul en console web tout à l’heure.

 WebsiteLoadBlancerListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties: 
      LoadBalancerArn: !Ref WebsiteLoadBalancer
      Port: 80
      Protocol: HTTP
      DefaultActions:
        - Type: forward
          TargetGroupArn: !Ref WebsiteTargetGroup

Rien de particulier dans cet élément : on fait référence aux éléments créés précédemment.

En résumé

  • AWS fournit différentes fonctions pour simplifier l’écriture des stacks comme Fn::Base64 ou Fn::Sub ;

  • certains paramètres du template sont gérés par AWS, comme AWS::Region ; ils sont appelés pseudo-paramètres ;

  • quand on spécifie un UserData en CloudFormation, celui-ci doit être encodé en Base64 ;

  • il faut explicitement ajouter un Listener à un Load Balancer pour permettre de recevoir du trafic ;

  • les Security Group doivent être créés à la fois pour la Launch Configuration et pour le Load Balancer.

Nous avons à présent une infrastructure automatisée dans AWS, mais nous n’avons pas du tout abordé sa maintenance. Comment gérer les sauvegardes ? Comment surveiller les machines ? Nous allons aborder tout cela dans la partie suivante, juste après le quiz.

Exemple de certificat de réussite
Exemple de certificat de réussite