ansible
Utiliser Ansible avec Amazon Web Services

Remarques

Comment démarrer l'instance EC2 à partir des AMI Amazon officielles, la modifier et la stocker en tant que nouvelle AMI

Il s'agit d'un workflow très courant lorsque vous utilisez Ansible pour provisionner une instance AWS EC2. Cet article suppose une compréhension de base d'Ansible et, surtout, suppose que vous l'avez correctement configuré pour se connecter à AWS.

Comme le souligne la documentation officielle d'Ansible , nous allons utiliser quatre rôles:

1- ami_find pour obtenir l'identifiant ami sur lequel nous allons lancer notre instance EC2.

2- ec2_ami_creation pour lancer efficacement l'instance EC2.

3- code_deploy pour modifier l'instance; Cela pourrait être n'importe quoi, nous transférerons donc simplement un fichier sur la machine cible.

4- build_ami pour construire notre nouvelle image basée sur l'instance ec2 en cours d'exécution. Ce post suppose que vous êtes au plus haut niveau de votre projet Ansible: my_ansible_project

Le premier rôle: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

Dans ce rôle, nous allons utiliser le module ec2_ami_find et, par exemple, nous rechercherons une machine Ubuntu et obtiendrons son ami_id (ami-xxxxxxxx). Maintenant, éditez le my_ansible_project/roles/ami_find/tasks/main.yml :

---
- ec2_ami_find:
    name: "ubuntu/images/hvm-ssd/ubuntu-trusty-14.04-amd64-server-*"
    sort: name
    sort_order: descending
    sort_end: 1
    region: "{{ aws_region }}"
  register: ami_find
- set_fact: ami_ubuntu="{{ ami_find.results[0].ami_id }}"

Le second rôle: ec2_ami_creation

Ici, nous allons utiliser l' ami_id nous avons obtenu du premier rôle, puis lancer notre nouvelle instance basée sur celle-ci:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

Dans ce rôle, nous allons surtout utiliser ec2_module pour lancer notre instance. Maintenant, éditez le my_ansible_project/roles/ec2_ami_creation/tasks/main.yml :

---
- ec2_vpc_subnet_facts:
    region: "{{aws_region}}"
  register: vpc
- name: creation of security group of the ec2 instance
  ec2_group:
    name: example
    description: an example EC2 group
    region: "{{ aws_region }}"
    rules:
      - proto: tcp
        from_port: 22
        to_port: 22
        cidr_ip: 0.0.0.0/0
    state: present
  register: ec2_sg

- name: create instance using Ansible
  ec2:
    key_name: "{{ ansible_key }}"
    group: example
    vpc_subnet_id: "{{vpc.subnets[0].id}}"
    instance_type: "{{ instance_type }}"
    ec2_region: "{{ aws_region }}"
    image: "{{ base_image }}"
    assign_public_ip: yes
    wait: yes
  register: ec2

- set_fact: id={{ec2.instances[0].id}}

- name: adding the newly created instance to a temporary group in order to access it later from another play
  add_host: name={{ item.public_ip }} groups=just_created
  with_items: ec2.instances

- name: Wait for SSH to come up
  wait_for: host={{ item.public_dns_name }} port=22 delay=10 timeout=640 state=started
  with_items: ec2.instances

Le troisième rôle: code_deploy

Ici, nous allons provisionner cette instance, qui a été ajoutée à un groupe appelé just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

Dans ce rôle, nous allons utiliser le template_module pour transférer un fichier et y écrire le nom d'hôte de la machine. Maintenant, éditez le my_ansible_project/roles/code_deploy/tasks/main.yml :

---
- template: src=my_file.txt.j2 dest=/etc/my_file.txt

puis déplacez-vous dans le dossier des modèles dans votre rôle:

cd my_ansible_project/roles/templates et ajouter un fichier nommé my_file.txt.j2 contenant:

my name is {{ ansible_hostname }}` 

Le quatrième rôle: build_ami

Nous allons maintenant créer une image de l'instance en cours d'exécution à l'aide du module ec2_ami . Déplacer vers votre dossier de projet et:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

Maintenant, éditez le my_ansible_project/roles/build_ami/tasks/main.yml :

---
- ec2_ami:
    instance_id: "{{ instance_id }}"
    wait: yes
    name: Base_Image

Maintenant, je pense que vous vous demandez comment orchestrer tous ces rôles. Ai-je raison? Si oui, continuez à lire.

Nous allons écrire un playbook, composé de trois jeux: le premier jeu applicable sur localhost appellera nos deux premiers rôles, le deuxième jeu s'appliquant à notre groupe just_created . Le dernier rôle sera applicable sur localhost . Pourquoi localhost ? Lorsque nous voulons gérer des ressources AWS, nous utilisons notre machine locale, aussi simple que cela. Ensuite, nous utiliserons un fichier vars dans lequel nous ansible_key nos variables: ansible_key , aws_region , etc ...

créer un dossier d'infrastructure en haut de votre projet et ajouter un fichier appelé aws.yml :

---
aws_region: ap-southeast-2
ansible_key: ansible
instance_type: t2.small

Donc, en haut de votre projet, créez build_base_image.yml et ajoutez ceci:

---
   - hosts: localhost
     connection: local
     gather_facts: False
     vars_files:
       - infrastructure/aws.yml
     roles:
       - ami_find
       - { role: ec2_creation, base_image: "{{ ami_ubuntu }}"}

   - hosts: just_created
     connection: ssh
     gather_facts: True
     become: yes
     become_method: sudo
     roles:
       - code_deploy

   - hosts: localhost
     connection: local
     gather_facts: False
     vars_files:
       - infrastructure/aws.yml
     roles:
       - { role: new_image, instance_id: "{{ id }}"}

Ça y est, n'oubliez pas de supprimer vos ressources après avoir testé ceci, ou pourquoi ne pas créer un rôle pour supprimer l'instance en cours d'exécution :-)

Comment configurer correctement Ansible pour se connecter à Amazon Web Services

La gestion des ressources AWS qui évoluent dans les limites du fichier hôte d'inventaire statique, c'est pourquoi nous avons besoin de quelque chose de dynamique. Et c'est à cela que servent les inventaires dynamiques . Commençons:

Téléchargez ces fichiers ec2.ini et ec2.py dans le dossier de votre projet:

cd my_ansible_project 
wget https://raw.githubusercontent.com/ansible/ansible/devel/contrib/inventory/ec2.py    
wget https://raw.githubusercontent.com/ansible/ansible/devel/contrib/inventory/ec2.ini

Une fois terminé, rendez le fichier ec2.py exécutable:

chmod +x ec2.py

Maintenant, exportez votre clé AWS Secret et Access en tant que variables d'environnement:

export AWS_ACCESS_KEY_ID='ABCDEFGHIJKLM'
export AWS_SECRET_ACCESS_KEY='NOPQRSTUVWXYZ'

Pour utiliser le script ec2.py , nous avons besoin du SDK Python AWS, boto , vous devez donc l'installer:

sudo pip install boto

Pour tester si tout va bien, essayez d’exécuter ec2.py en listant vos ressources:

./ec2.py --list

vous devriez voir quelque chose de similaire à:

{
  "_meta": {
    "hostvars": {}
  }
}

Maintenant, nous voulons utiliser l'inventaire dynamique avec notre fichier d'hôtes statique. Tout d'abord, créez un dossier appelé « inventory , ajoutez-lui « ec2.py , « ec2.ini et notre fichier hosts , puis indiquez à Ansible d'utiliser ce dossier comme fichier d'inventaire:

mkdir inventory 
mv ec2.py inventory/ec2.py
mv ec2.ini inventory/ec2.ini
mv hosts inventory/hosts

Ensuite, nous devons définir la configuration au niveau du projet pour Ansible en créant un fichier de configuration Ansible dans votre dossier de projet appelé ansible.cfg et en ajoutant ceci:

[defaults]
hostfile = inventory
[ssh_connection]
pipelining = False
ssh_args = -o ControlMaster=auto -o ControlPersist=30m -o StrictHostKeyChecking=no

Ensuite, nous devons configurer Ansible pour utiliser une clé SSH pour authentifier l'accès à nos instances EC2. L'utilisation d'un agent SSH est le meilleur moyen de s'authentifier avec les ressources, car cela facilite la gestion des clés:

ssh-agent bash 
ssh-add ~/.ssh/keypair.pem  

C'est tout! Si vous avez suivi cela, vous pouvez le tester en utilisant le module ping , puis vous verrez vos instances en cours d'exécution configurées pour utiliser votre clé en réponse avec pong:

ansible -m ping all
11.22.33.44 | success >> {
    "changed": false, 
    "ping": "pong"
}