ansible
Korzystanie z Ansible z Amazon Web Services

Uwagi

Jak uruchomić instancję EC2 z oficjalnych AMI Amazon, zmodyfikować ją i zapisać jako nową AMI

Jest to bardzo powszechny przepływ pracy w przypadku korzystania z Ansible do obsługi instancji AWS EC2. Ten post zakłada podstawową znajomość Ansible i, co najważniejsze, zakłada, że poprawnie skonfigurowałeś go, aby połączyć się z AWS.

Jak podkreśla oficjalna dokumentacja Ansible , będziemy używać czterech ról:

1- ami_find, aby uzyskać identyfikator ami, na podstawie którego uruchomimy naszą instancję EC2.

2- ec2_ami_creation, aby skutecznie uruchomić instancję EC2.

3- code_deploy do modyfikowania instancji; może to być cokolwiek, więc po prostu przeniesiemy plik na maszynę docelową.

4- build_ami, aby zbudować nasz nowy obraz w oparciu o działającą instancję ec2. Ten post zakłada, że jesteś na najwyższym poziomie projektu my_ansible_project : my_ansible_project

Pierwsza rola: ami_find

cd my_ansible_project/roles && ansible-galaxy init ami_find

W tej roli użyjemy modułu ec2_ami_find , a jako przykład będziemy szukać maszyny Ubuntu i uzyskamy jej ami_id (ami-xxxxxxxx). Teraz edytuj 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 }}"

Druga rola: ec2_ami_creation

Tutaj użyjemy ami_id który otrzymaliśmy od pierwszej roli, a następnie uruchomimy naszą nową instancję na tej podstawie:

cd my_ansible_project/roles && ansible-galaxy init ec2_ami_creation

W tej roli wykorzystamy przede wszystkim moduł ec2_module do uruchomienia naszej instancji. Teraz edytuj 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

Trzecia rola: code_deploy

Tutaj zapewnimy tę instancję, która została dodana do grupy o nazwie just_created

cd my_ansible_project/roles && ansible-galaxy init code_deploy

W tej roli użyjemy modułu szablon do przesłania pliku i zapisania w nim nazwy hosta maszyny. Teraz edytuj my_ansible_project/roles/code_deploy/tasks/main.yml :

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

następnie przejdź do folderu szablonów w swojej roli:

cd my_ansible_project/roles/templates i dodaj plik o nazwie my_file.txt.j2 zawierający:

my name is {{ ansible_hostname }}` 

Czwarta rola: build_ami

Teraz utworzymy obraz działającej instancji za pomocą modułu ec2_ami . Przejdź do folderu projektu i:

 cd my_ansible_project/roles && ansible-galaxy init build_ami

Teraz edytuj my_ansible_project/roles/build_ami/tasks/main.yml :

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

Myślę, że zastanawiałeś się, jak zaaranżować wszystkie te role. Czy mam rację? Jeśli tak, kontynuuj czytanie.

Napiszemy poradnik , składający się z trzech sztuk: pierwsza gra dostępna na localhost wywoła dwie pierwsze role, druga gra dotyczy naszej grupy just_created . ostatnia rola będzie obowiązywać na localhost . Dlaczego localhost ? Kiedy chcemy zarządzać niektórymi zasobami AWS, używamy naszej lokalnej maszyny, tak proste. Następnie użyjemy pliku vars, w którym umieścimy nasze zmienne: ansible_key , aws_region itp.

utwórz folder infrastruktury u góry projektu i dodaj do niego plik o nazwie aws.yml :

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

Więc u góry projektu utwórz build_base_image.yml i dodaj to:

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

To jest to, nie zapomnij usunąć zasobów po przetestowaniu tego, albo dlaczego nie utworzyć roli, aby usunąć działającą instancję :-)

Jak poprawnie skonfigurować Ansible, aby połączyć się z Amazon Web Services

Zarządzanie zasobami AWS, które skaluje się w górę i w dół, mieści się w granicach pliku hosta zapasów statycznych, dlatego potrzebujemy czegoś dynamicznego. I po to są dynamiczne zapasy . Zaczynajmy:

Pobierz te pliki ec2.ini i ec2.py do folderu projektu:

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

Po zakończeniu ec2.py plik ec2.py :

chmod +x ec2.py

Teraz wyeksportuj klucz tajny i klucz dostępu AWS jako zmienne środowiskowe:

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

Aby użyć skryptu ec2.py , potrzebujemy ec2.py SDK Python AWS, boto więc musisz go zainstalować:

sudo pip install boto

Aby sprawdzić, czy wszystko jest w porządku, spróbuj uruchomić ec2.py swoje zasoby:

./ec2.py --list

powinieneś zobaczyć coś podobnego do:

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

Teraz chcemy korzystać z dynamicznej inwentaryzacji wraz z naszym statycznym plikiem hosts. Najpierw utwórz folder o nazwie inventory , dodaj do niego plik ec2.py , ec2.ini i nasz plik hosts , a następnie powiedz Ansible, aby używał tego folderu jako pliku ekwipunku:

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

Następnie powinniśmy zdefiniować konfigurację na poziomie projektu dla Ansible, tworząc plik konfiguracyjny Ansible w folderze projektu o nazwie ansible.cfg i dodając to:

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

Następnie musimy skonfigurować Ansible, aby używał klucza SSH do uwierzytelnienia dostępu do naszych instancji EC2. Użycie agenta SSH jest najlepszym sposobem uwierzytelnienia za pomocą zasobów, ponieważ ułatwia zarządzanie kluczami:

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

Otóż to! Jeśli to zrobisz, możesz to przetestować za pomocą modułu ping , a następnie zobaczysz działające instancje, które zostały skonfigurowane do używania klucza odpowiadającego za pomocą ponga:

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