ansible
Ansible gebruiken met Amazon Web Services

Opmerkingen

Hoe EC2-instantie te starten vanuit officiële Amazon AMI's, deze te wijzigen en op te slaan als nieuwe AMI

Dit is een veel voorkomende workflow bij het gebruik van Ansible voor het inrichten van een AWS EC2-instantie. Dit bericht gaat uit van een basiskennis van Ansible en, belangrijker nog, gaat ervan uit dat je het correct hebt geconfigureerd om verbinding te maken met AWS.

Zoals de officiële documentatie van Ansible aandringt , gaan we vier rollen gebruiken:

1- ami_find om de ami id te krijgen op basis waarvan we ons EC2-exemplaar gaan lanceren.

2- ec2_ami_creation om de EC2-instantie effectief te starten.

3- code_deploy voor het wijzigen van de instantie; dit kan van alles zijn, dus we zullen gewoon een bestand overbrengen naar de doelmachine.

4- build_ami om onze nieuwe afbeelding te bouwen op basis van het actieve ec2-exemplaar. In dit bericht wordt ervan uitgegaan dat u zich op het hoogste niveau van uw Ansible-project bevindt: my_ansible_project

De eerste rol: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

In deze rol gaan we de module ec2_ami_find gebruiken en als voorbeeld zoeken we naar een een Ubuntu-machine en krijgen we de ami_id (ami-xxxxxxxx). Bewerk nu my_ansible_project/roles/ami_find/tasks/main.yml bestand:

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

De tweede rol: ec2_ami_creation

Hier zullen we de ami_id we van de eerste rol hebben gekregen en vervolgens onze nieuwe instantie op basis hiervan lanceren:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

In deze rol gaan we vooral de ec2_module gebruiken om onze instantie te starten. Bewerk nu my_ansible_project/roles/ec2_ami_creation/tasks/main.yml bestand:

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

De derde rol: code_deploy

Hier zullen we dit exemplaar just_created , dat is toegevoegd aan een groep met de naam just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

In deze rol gaan we de template_module gebruiken om een bestand over te zetten en de hostnaam van de machine erin te schrijven. Bewerk nu my_ansible_project/roles/code_deploy/tasks/main.yml bestand:

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

ga vervolgens naar de map met sjablonen in uw rol:

cd my_ansible_project/roles/templates en voeg een bestand met de naam my_file.txt.j2 met:

my name is {{ ansible_hostname }}` 

De vierde rol: build_ami

We zullen nu een afbeelding van de actieve instantie maken met behulp van de ec2_ami-module . Ga naar je projectmap en:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

Bewerk nu my_ansible_project/roles/build_ami/tasks/main.yml bestand:

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

Nu denk ik dat je je hebt afgevraagd hoe je al deze rollen kunt orkestreren. Heb ik gelijk? Zo ja, lees dan verder.

We zullen een playbook schrijven, bestaande uit drie toneelstukken: het eerste spel van toepassing op localhost zal onze eerste twee rollen noemen, het tweede spel van toepassing op onze just_created groep. laatste rol zal van toepassing zijn op localhost . Waarom localhost ? Wanneer we sommige AWS-bronnen willen beheren , gebruiken we onze lokale machine, zo simpel als dat. Vervolgens zullen we een vars-bestand gebruiken waarin we onze variabelen plaatsen: ansible_key , aws_region , etc ...

maak een infrastructuurmap bovenaan uw project en voeg daarin een bestand toe genaamd aws.yml :

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

Maak dus bovenaan uw project build_base_image.yml en voeg dit toe:

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

Dat is alles, vergeet niet uw bronnen te verwijderen nadat u dit hebt getest, of waarom geen rol maken om de actieve instantie te verwijderen :-)

Hoe Ansible correct te configureren om verbinding te maken met Amazon Web Services

Het beheren van AWS-bronnen die op en neer gaan, loopt tegen de grenzen van het statische voorraadhostbestand aan, daarom hebben we iets dynamisch nodig. En daar zijn de dynamische inventarissen voor. Laten we beginnen:

Download deze ec2.ini- en ec2.py- bestanden naar uw projectmap:

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

Maak het ec2.py bestand ec2.py uitvoerbaar:

chmod +x ec2.py

Exporteer nu uw AWS Secret- en Access-sleutel als omgevingsvariabelen:

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

Om het ec2.py script te gebruiken, hebben we de Python AWS SDK nodig, boto dus je moet het installeren:

sudo pip install boto

Om te testen of alles goed is, probeer je ec2.py door je bronnen te vermelden:

./ec2.py --list

je zou iets moeten zien dat lijkt op:

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

Nu willen we de dynamische inventaris samen met ons statische hosts-bestand gebruiken. Maak eerst een map met de naam inventory , voeg ec2.py , ec2.ini en ons hosts bestand toe en vertel vervolgens aan Ansible om die map te gebruiken als inventarisbestand:

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

Vervolgens moeten we de configuratie op projectniveau voor Ansible definiëren door een Ansible-configuratiebestand te maken in uw projectmap met de naam ansible.cfg en dit toe te voegen:

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

Vervolgens moeten we Ansible configureren om een SSH-sleutel te gebruiken om de toegang tot onze EC2-instanties te verifiëren. Het gebruik van een SSH-agent is de beste manier om met bronnen te verifiëren, omdat dit het eenvoudiger maakt om sleutels te beheren:

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

Dat is het! Als je dit hebt gevolgd, kun je het testen met behulp van de ping module en dan zie je je actieve instanties die zijn geconfigureerd om je sleutel te gebruiken met pong:

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