ansible
Använda Ansible med Amazon Web Services

Anmärkningar

Hur man startar EC2-instans från officiella Amazon AMI: er, ändrar den och lagrar den som ny AMI

Detta är ett mycket vanligt arbetsflöde när du använder Ansible för att tillhandahålla en AWS EC2-instans. Det här inlägget antar en grundläggande förståelse av Ansible och viktigast av allt förutsätter att du har konfigurerat det för att ansluta till AWS.

Som ansvarsfull officiell dokumentation insisterar kommer vi att använda fyra roller:

1- ami_find för att få ami-id baserat på vilket vi kommer att starta vår EC2-instans.

2- ec2_ami_creation för att effektivt lansera EC2-instansen.

3 - kod_deploy för att modifiera instansen; detta kan vara vad som helst så att vi helt enkelt överför en fil till målmaskinen.

4- build_ami för att bygga vår nya bild baserad på den löpande ec2-instansen. Det här inlägget antar att du är på toppnivån i ditt Ansible-projekt: my_ansible_project

Den första rollen: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

I den här rollen kommer vi att använda modulen ec2_ami_find och som ett exempel kommer vi att söka efter en Ubuntu-maskin och få dess ami_id (ami-xxxxxxxx). my_ansible_project/roles/ami_find/tasks/main.yml nu my_ansible_project/roles/ami_find/tasks/main.yml fil:

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

Den andra rollen: ec2_ami_creation

Här kommer vi att använda det ami_id vi fick från den första rollen och sedan lansera vår nya instans baserad på den:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

I denna roll kommer vi att använda det viktigaste av ec2_modulen för att lansera vår instans. my_ansible_project/roles/ec2_ami_creation/tasks/main.yml nu my_ansible_project/roles/ec2_ami_creation/tasks/main.yml fil:

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

Den tredje rollen: code_deploy

Här kommer vi att tillhandahålla den här instansen, som lades till en grupp som heter just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

I den här rollen kommer vi att använda mall_modulen för att överföra en fil och skriva maskinens värdnamn i den. my_ansible_project/roles/code_deploy/tasks/main.yml nu my_ansible_project/roles/code_deploy/tasks/main.yml fil:

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

flytta sedan till mappmappen i din roll:

cd my_ansible_project/roles/templates och lägg till en fil som heter my_file.txt.j2 innehåller:

my name is {{ ansible_hostname }}` 

Den fjärde rollen: build_ami

Vi kommer nu att skapa en bild av den löpande instansen med modulen ec2_ami . Flytta till din projektmapp och:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

my_ansible_project/roles/build_ami/tasks/main.yml nu my_ansible_project/roles/build_ami/tasks/main.yml fil:

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

Nu tror jag att du har undrat hur du orkestrerar alla dessa roller. Har jag rätt? Om så är fallet, fortsätt att läsa.

Vi kommer att skriva en spellista, som består av tre stycken: det första spelet som är tillämpligt på localhost kommer att kalla våra två första roller, det andra stycket som gäller för vår just_created grupp. sista roll kommer att tillämpas på localhost . Varför localhost ? När vi vill hantera vissa AWS-resurser använder vi vår lokala maskin, så enkel som den. Därefter använder vi en vars-fil där vi kommer att lägga våra variabler: ansible_key , aws_region , etc. ...

skapa infrastrukturmapp längst upp i ditt projekt och lägg till en fil i den som heter aws.yml :

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

Så högst upp i ditt projekt skapar build_base_image.yml och lägg till detta:

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

Det är det, glöm inte att ta bort dina resurser efter att ha testat det, eller varför inte skapa en roll för att ta bort den instans som körs :-)

Hur du konfigurerar Ansible korrekt för att ansluta till Amazon Web Services

Att hantera AWS-resurser som skalas upp och ner går i gränserna för värdfilen för statisk inventering, det är därför vi behöver något dynamiskt. Och det är vad de dynamiska varulagerna är till för. Låt oss börja:

Ladda ner dessa ec2.ini- och ec2.py- filer till din projektmapp:

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

När du är klar gör ec2.py filen körbar:

chmod +x ec2.py

Exportera nu din AWS Secret och Access-nyckel som miljövariabler:

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

För att använda skriptet ec2.py behöver vi Python AWS SDK, boto så du måste installera det:

sudo pip install boto

För att testa om allt är bra, försök att utföra ec2.py genom att ange dina resurser:

./ec2.py --list

du bör se något liknande:

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

Nu vill vi använda den dynamiska inventeringen tillsammans med vår statiska värdfil. Skapa först en mapp som heter inventory , lägg ec2.py , ec2.ini och våra hosts filen till den berättar sedan Ansible att använda denna mapp som en inventering fil:

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

Därefter bör vi definiera projektnivåkonfiguration för Ansible genom att skapa en Ansible config-fil i din projektmapp som heter ansible.cfg och lägga till denna:

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

Nästa måste vi konfigurera Ansible för att använda en SSH-nyckel för att autentisera åtkomst till våra EC2-instanser. Att använda en SSH-agent är det bästa sättet att autentisera med resurser, eftersom det gör det lättare att hantera nycklar:

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

Det är allt! Om du följde detta kan du testa det med ping och sedan ser du dina körförekomster som har konfigurerats för att använda din nyckel som svarar med pong:

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