ansible
Usando Ansible con Amazon Web Services

Observaciones

Cómo iniciar la instancia de EC2 desde las AMI oficiales de Amazon, modificarla y almacenarla como nueva AMI

Este es un flujo de trabajo muy común cuando se utiliza Ansible para aprovisionar una instancia de AWS EC2. Esta publicación supone un conocimiento básico de Ansible y, lo que es más importante, supone que la ha configurado correctamente para conectarse a AWS.

Como insiste la documentación oficial de Ansible , vamos a utilizar cuatro roles:

1- ami_find para obtener el ID de ami en función del cual lanzaremos nuestra instancia de EC2.

2- ec2_ami_creation para lanzar efectivamente la instancia de EC2.

3- code_deploy para modificar la instancia; Esto podría ser cualquier cosa, así que simplemente transferiremos un archivo a la máquina de destino.

4- build_ami para construir nuestra nueva imagen basada en la instancia de ec2 en ejecución. Esta publicación asume que estás en el nivel superior de tu proyecto de Ansible: my_ansible_project

El primer rol: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

En este rol vamos a usar el módulo ec2_ami_find y, como ejemplo, buscaremos una máquina Ubuntu y obtendremos su ami_id (ami-xxxxxxxx). Ahora edite el 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 }}"

El segundo rol: ec2_ami_creation

Aquí, usaremos el ami_id que obtuvimos del primer rol y luego ami_id nuestra nueva instancia basada en él:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

En este rol, vamos a utilizar lo más importante el módulo ec2 para lanzar nuestra instancia. Ahora edite my_ansible_project/roles/ec2_ami_creation/tasks/main.yml file:

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

El tercer rol: code_deploy

Aquí, aprovisionaremos esta instancia, que se agregó a un grupo llamado just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

En este rol, vamos a utilizar el template_module para transferir un archivo y escribir el nombre de host de la máquina en él. Ahora edite el my_ansible_project/roles/code_deploy/tasks/main.yml :

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

Luego, muévase a la carpeta de plantillas dentro de su rol:

cd my_ansible_project/roles/templates y agregue un archivo llamado my_file.txt.j2 contiene:

my name is {{ ansible_hostname }}` 

El cuarto papel: build_ami

Ahora crearemos una imagen de la instancia en ejecución usando el módulo ec2_ami . Mueve a tu carpeta de proyectos y:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

Ahora edite el my_ansible_project/roles/build_ami/tasks/main.yml :

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

Ahora, creo que te has estado preguntando cómo organizar todos estos roles. Estoy en lo cierto Si es así, sigue leyendo.

Escribiremos un libro de jugadas, compuesto por tres jugadas: la primera jugada aplicable en localhost llamará a nuestras dos primeras funciones, la segunda jugada se aplicará a nuestro grupo just_created . El último rol será aplicable en localhost . ¿Por qué localhost ? Cuando queremos administrar algunos recursos de AWS, usamos nuestra máquina local, tan simple como eso. A continuación, usaremos un archivo vars en el que pondremos nuestras variables: ansible_key , aws_region , etc.

cree una carpeta de infraestructura en la parte superior de su proyecto y agregue un archivo dentro llamado aws.yml :

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

Así que en la parte superior de tu proyecto crea build_base_image.yml y agrega esto:

---
   - 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 }}"}

Eso es todo. No olvide eliminar sus recursos después de probar esto, o por qué no crear una función para eliminar la instancia en ejecución :-)

Cómo configurar correctamente Ansible para conectarse a los servicios web de Amazon

La administración de los recursos de AWS que escalan hacia arriba y hacia abajo se encuentra dentro de los límites del archivo host de inventario estático, es por eso que necesitamos algo dinámico. Y para eso están los inventarios dinámicos . Empecemos:

Descargue estos archivos ec2.ini y ec2.py en la carpeta de su proyecto:

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

Una vez hecho esto, haga el archivo ec2.py ejecutable:

chmod +x ec2.py

Ahora, exporte su clave de acceso y secreto de AWS como variables de entorno:

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

Para usar el script ec2.py necesitamos el SDK de Python AWS, boto , por lo que necesita instalarlo:

sudo pip install boto

Para probar si todo está bien, intente ejecutar el ec2.py enumerando sus recursos:

./ec2.py --list

Deberías ver algo similar a:

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

Ahora queremos usar el inventario dinámico junto con nuestro archivo de hosts estáticos. Primero, cree una carpeta llamada inventory , agregue ec2.py , ec2.ini y nuestro archivo de hosts y luego diga a Ansible que use esa carpeta como un archivo de inventario:

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

A continuación, debemos definir la configuración a nivel de proyecto para Ansible creando un archivo de configuración de Ansible en su carpeta de proyecto llamada ansible.cfg y agregando esto:

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

A continuación, debemos configurar Ansible para usar una clave SSH para autenticar el acceso a nuestras instancias de EC2. Usar un agente de SSH es la mejor manera de autenticarse con recursos, ya que esto facilita la administración de claves:

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

¡Eso es! Si siguió esto, puede probarlo utilizando el módulo ping y luego verá las instancias en ejecución que se han configurado para usar su clave respondiendo con pong:

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