ansible
Utilizzo di Ansible con Amazon Web Services

Osservazioni

Come avviare l'istanza EC2 dalle AMI Amazon ufficiali, modificarlo e memorizzarlo come nuovo AMI

Questo è un flusso di lavoro molto comune quando si utilizza Ansible per il provisioning di un'istanza AWS EC2. Questo post presuppone una comprensione di base di Ansible e, cosa più importante, presuppone che l'hai configurato correttamente per connettersi ad AWS.

Come insiste la documentazione ufficiale di Ansible , useremo quattro ruoli:

1- ami_find per ottenere l'id di ami in base al quale lanceremo la nostra istanza EC2.

2- ec2_ami_creation per avviare in modo efficace l'istanza EC2.

3- code_deploy per la modifica dell'istanza; questo potrebbe essere qualsiasi cosa, quindi trasferiremo semplicemente un file sul computer di destinazione.

4- build_ami per costruire la nostra nuova immagine basata sull'istanza di ec2 in esecuzione. Questo post presuppone che tu sia al livello più alto del tuo progetto Ansible: my_ansible_project

Il primo ruolo: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

In questo ruolo useremo il modulo ec2_ami_find e ad esempio, cercheremo una macchina Ubuntu e otterremo il suo ami_id (ami-xxxxxxxx). Ora modifica il file 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 }}"

Il secondo ruolo: ec2_ami_creation

Qui, useremo ami_id abbiamo ottenuto dal primo ruolo e poi lanciamo la nostra nuova istanza basata su di esso:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

In questo ruolo useremo il più importante ec2_module per lanciare la nostra istanza. Ora modifica il file 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

Il terzo ruolo: code_deploy

Qui forniremo questa istanza, che è stata aggiunta a un gruppo chiamato just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

In questo ruolo useremo template_module per trasferire un file e scrivere il nome host della macchina in esso. Ora modifica il file my_ansible_project/roles/code_deploy/tasks/main.yml :

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

quindi passa alla cartella dei modelli all'interno del tuo ruolo:

cd my_ansible_project/roles/templates e aggiungi un file chiamato my_file.txt.j2 contenente:

my name is {{ ansible_hostname }}` 

Il quarto ruolo: build_ami

Creeremo ora un'immagine dell'istanza in esecuzione usando il modulo ec2_ami . Passare alla cartella del progetto e:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

Ora modifica il file my_ansible_project/roles/build_ami/tasks/main.yml :

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

Ora, penso che ti stia chiedendo come orchestrare tutti questi ruoli. Ho ragione? Se è così, continua a leggere.

Scriveremo un playbook, composto da tre giochi: la prima giocata applicabile su localhost chiamerà i nostri primi due ruoli, la seconda giocata applicabile al nostro gruppo just_created . l'ultimo ruolo sarà applicabile su localhost . Perché localhost ? Quando vogliamo gestire alcune risorse AWS, usiamo la nostra macchina locale, così semplice. Successivamente, utilizzeremo un file vars in cui metteremo le nostre variabili: ansible_key , aws_region , ecc ...

crea una cartella infrastruttura nella parte superiore del tuo progetto e aggiungi un file al suo interno chiamato aws.yml :

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

Quindi, all'inizio del tuo progetto, crea build_base_image.yml e aggiungi questo:

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

È così, non dimenticare di eliminare le risorse dopo aver provato questo, o perché non creare un ruolo per eliminare l'istanza in esecuzione :-)

Come configurare correttamente Ansible per connettersi ad Amazon Web Services

Gestire le risorse AWS che scalano le corse su e giù nei limiti del file host dell'inventario statico, ecco perché abbiamo bisogno di qualcosa di dinamico. Ed è a questo che servono gli inventari dinamici . Iniziamo:

Scarica questi file ec2.ini ed ec2.py nella cartella del tuo progetto:

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

Al termine, rendere eseguibile il file ec2.py :

chmod +x ec2.py

Esportare ora la chiave segreta e di accesso di AWS come variabili di ambiente:

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

Per utilizzare lo script ec2.py abbiamo bisogno di Python AWS SDK, boto quindi è necessario installarlo:

sudo pip install boto

Per verificare se tutto è a posto, prova a eseguire ec2.py elencando le tue risorse:

./ec2.py --list

dovresti vedere qualcosa di simile a:

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

Ora vogliamo utilizzare l'inventario dinamico insieme al nostro file host statico. Per prima cosa, crea una cartella chiamata inventory , aggiungi ec2.py , ec2.ini e il nostro file hosts , quindi dì ad Ansible di usare quella cartella come un file di inventario:

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

Successivamente dovremmo definire la configurazione a livello di progetto per Ansible creando un file di configurazione Ansible nella cartella del tuo progetto chiamato ansible.cfg e aggiungendo questo:

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

Successivamente dobbiamo configurare Ansible per utilizzare una chiave SSH per autenticare l'accesso alle nostre istanze EC2. L'utilizzo di un agente SSH è il modo migliore per autenticarsi con le risorse, in quanto ciò semplifica la gestione delle chiavi:

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

Questo è tutto! Se lo hai seguito, puoi testarlo utilizzando il modulo ping e poi vedrai le istanze in esecuzione che sono state configurate per utilizzare la tua chiave che risponde con pong:

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