Hvordan lage Ansible skuespill og Playbooks - Del 5


I denne Del 5 av Ansible-serien vil vi forklare hvordan du lager Ansible Plays og Playbooks ved å bruke Ansible-moduler.

Ansible leveres med frittstående skript kalt moduler som brukes i playbooks for utføring av spesialiserte oppgaver på eksterne noder.

Moduler kommer godt med for å automatisere oppgaver som pakkehåndtering, arkivering og kopiering av filer for å nevne noen. De lar deg gjøre justeringer på konfigurasjonsfiler og administrere enheter som rutere, brytere, lastbalansere, brannmurer og en rekke andre enheter.

Målet med dette underemnet er å gi deg en oversikt over ulike oppgaver som kan utføres av Ansible moduler:

Pakkebehandling i Linux

Pakkeadministrasjon er en av de mest essensielle og hyppigste oppgavene som utføres av systemadministratorer. Ansible leveres med moduler som hjelper deg med å utføre pakkehåndteringsoppgaver både i RedHat- og Debian-baserte systemer.

De er relativt enkle å gjette. Det er apt-modulen for APT-pakkeadministrasjon for Debian-basert, den gamle yum-modulen for YUM-pakkeadministrasjon og dnf-modulen knyttet til nyere RHEL-distribusjoner .

Nedenfor er noen eksempler på hvordan modulene kan brukes i en spillebok:

Eksempel 1: Installere Apache Webserver på RHEL 8

---
- name: install Apache webserver
  hosts: webservers

  tasks:
       - name: install httpd
         dnf:  
          name: httpd  
          State: latest

Eksempel 2: Installere Apache Webserver på Debian 10

---
- name: install Apache webserver
  hosts: databases

  tasks:
       - name: install Apache webserver
         apt:  
          name: apache2  
          State: latest

Servicemodul

Servicemodulen lar systemadministratorer starte, stoppe, oppdatere, oppgradere og laste inn tjenester på systemet på nytt.

Eksempel 1: Starte Apache Webserver

---
- name: Start service httpd, if not started
  service:
    name: httpd
    state: started

Eksempel 2: Stoppe Apache Webserver

---
- name: Stop service httpd
  service:
    name: httpd
    state: stopped

Eksempel 3: Starte et nettverksgrensesnitt på nytt enp2s0

---
- name: Restart network service for interface eth0
  service:
    name: network
    state: restarted
    args: enp2s0

Kopier modul

Som navnet antyder, kopierer kopimodulen filer fra ett sted på den eksterne maskinen til et annet sted på samme maskin.

Eksempel 1: Kopiering av filer fra lokalt til eksternt Linux

---
- name: Copy file with owner and permissions
  copy:
    src: /etc/files/tecmint.conf
    dest: /srv/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: '0644'

Spilleboken kopierer konfigurasjonsfilen tecmint.conf fra katalogen /etc/files/ til katalogen /srv/ som tecmint > bruker med 0644-tillatelser.

Tillatelser kan også representeres ved hjelp av symbolsk representasjon som vist på siste linje.

Eksempel 2: Kopiering av filer fra lokalt til eksternt Linux

---
- name: Copy file with owner and permissions
  copy:
    src: /etc/files/tecmint.conf
    dest: /srv/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: u=rw, g=r, o=r

Tillatelsene i forrige eksempel kan representeres som vist på siste linje, Brukeren tildeles lese og skrive tillatelser, gruppen tildeles skriverettigheter, og resten av verden er tildelt lesetillatelser.

Filmodul

Filmodulen brukes til å utføre mange filoperasjoner, inkludert å lage filer og kataloger, tildele filtillatelser og sette symbolkoblinger.

Eksempel 1: Utfør Linux-filtillatelser

---
- name: Change file ownership, group, and permissions
  file:
    path: /etc/tecmint.conf
    owner: tecmint
    group: tecmint
    mode: '0644'

Avspillingen ovenfor oppretter en fil kalt tecmint.conf i katalogen /etc og setter tillatelser til 0644.

Eksempel 2: Slett Linux-fil

---
- name: Remove file (delete file)
  file:
    path: /etc/tecmint.conf
    state: absent

Dette fjerner eller sletter filen tecmint.conf.

Eksempel 3: Opprett en katalog

---
- name: create a directory if it doesn’t exist
  file:
    path: /etc/mydirectory
    State: directory
    mode: '0777'

Dette vil opprette en katalog i /etc-katalogen som har tillatelser til 0777.

Eksempel 4: Slett en katalog rekursivt

---
- name: Recursively deleting a  directory
  file:
    path: /etc/tecmint.conf
    state: absent

Avspillingen ovenfor sletter en katalog rekursivt.

Lineinfile-modul

Modulen lineinfile er nyttig når du vil endre en enkelt linje i en fil. Den kan erstatte en eksisterende linje.

Eksempel 1: Manipuler filer i Linux

---
 - name: Ensure SELinux is set to enforcing mode
  lineinfile:
    path: /etc/selinux/config
    regexp: '^SELINUX='
    line: SELINUX=disabled

Avspillingen ovenfor setter SELINUX-verdien til deaktivert.

SELINUX=disabled

Eksempel 2: Endre filer i Linux

---
- name: Add a line to a file if the file does not exist, without         passing regexp
  lineinfile:
    path: /etc/hosts
    line: 10.200.50.51 linux-console.net
    create: yes

Dette legger til oppføringen 10.200.50.51 linux-console.net til /etc/hosts-filen.

Arkivmodul

En Arkiv-modul brukes til å lage et komprimert arkiv med en enkelt eller flere filer. Det forutsetter at komprimeringskilden eksisterer er til stede på måldestinasjonen. Etter arkivering kan kildefilen senere slettes eller fjernes ved å bruke setningen remove=True.

Eksempel 1: Lag en arkivfil

- name: Compress directory /path/to/tecmint_dir/ into /path/to/tecmint.tgz
  archive:
    path: /path/to/tecmint_dir
    dest: /path/to/tecmint.tgz

This compresses the /path/to/tecmint_dir  directory to /path/to/tecmint.tgz

Eksempel 2: Lag en arkivfil og fjern

- name: Compress regular file /path/to/tecmint into /path/to/foo.gz and remove it
  archive:
    path: /path/to/tecmint
    dest: /path/to/tecmint.tgz
    remove: yes

I avspillingen ovenfor slettes kildefilen /path/to/tecmint etter at arkiveringen er fullført.

Eksempel 3: Lag en arkivfil

- name: Create a bz2 archive of /path/to/tecmint
  archive:
    path: /path/to/tecmint
    format: bz2

Dette oppretter en komprimert fil i bz2-format fra /path/to/tecmint-filen.

Git-modul

Modulen administrerer git-utsjekker av programvarelagre.

Eksempel 1: Sjekk Git Repositoires

- git:
    repo: 'https://foosball.example.org/path/to/repo.git'
    dest: /srv/checkout
    version: release-0.22

Kommandomodul

En av de mest brukte modulene, kommando-modulen, tar kommandonavnet og senere etterfulgt av en liste med argumenter. Kommandoen er bestått på samme måte som du ville skrevet inn i et Linux-skall.

Eksempel 1: Kjør en kommando

- name: Executing a command using the command module
  command: cat helloworld.txt

Eksempel 2: Sjekk Oppetid for Remote Linux

---
 - name: Check the remote host uptime
    hosts: servers
    tasks:
      - name: Execute the Uptime command over Command module
        register: uptimeoutput
        command: "uptime"

- debug:
          var: uptimeoutput.stdout_lines

Kommandomodulen henter oppetiden til eksterne servere.

Variabler for å hente resultatene av kjørende kommandoer

Vanligvis brukes Ansible-spillebøker til å utføre oppgaver på administrerte verter uten å vise utdataene på kommandolinjen. Det er imidlertid tilfeller der du kan bli bedt om å fange opp resultatet eller resultatene. I denne delen leder vi deg gjennom hvordan du kan fange utdataene fra en spillebok i en variabel og senere vise den.

Et ansible register brukes for å fange opp en oppgaves utdata og lagre den som en variabel. Variabelen vil deretter inneholde stdout for oppgaven.

La oss for eksempel anta at du vil sjekke diskbruken til administrerte noder i respektive rotkataloger ved å bruke kommandoen df -Th /. Du skal bruke 'kommando'-modulen for å definere kommandoen og 'register' for å lagre std-utgangen i en variabel.

For å vise kommandoen, bruker du 'debug'-modulen sammen med standard-returverdien.

---

 - hosts: all
   become: yes

   tasks:
     - name: Execute /boot usage on Hosts
       command: 'df -Th /'
       register: df

     - debug: var=df.stdout

La oss nå kjøre spilleboken. I dette tilfellet har vi kalt spilleboken vår check_disk_space.yml.

ansible-playbook check_disk_space.yml

Som du har sett, er utdataene rotete sammen og gjør det vanskelig å følge med.

For å justere utdataene og gjøre det lettere å lese, erstatte stdout-returverdien med stdout_lines.

---

 - hosts: all
   become: yes

   tasks:
     - name: Execute /boot usage on Hosts
       command: 'df -Th /'
       register: df

     - debug: var=df.stdout_lines

Bruk betingelser for å kontrollere avspillingsutførelsen

Akkurat som i programmeringsspråk, brukes betingede utsagn når mer enn ett utfall er mulig. La oss ta en titt på noen av de ofte brukte betingede utsagnene i Ansible playbooks.

Når uttalelse

Noen ganger vil du kanskje utføre oppgaver på bestemte noder og ikke andre. Den betingede setningen 'when' er ganske enkel å bruke og implementere i en playbook. Når du bruker 'when'-leddet, erklærer du ganske enkelt betingelsen ved siden av leddet som vist:

when: condition

Når betingelsen er oppfylt, utføres oppgaven på det eksterne systemet.

La oss se på noen eksempler:

Eksempel 1: Bruk av When Operator

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian”

Spillet ovenfor installerer Nginx nettserver på verter som kjører Debian-familien av distroer.

Du kan også bruke OR- og AND-operatorene sammen med når den betingede setningen.

Eksempel 2: Bruk av AND Operator med When

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian” and
           ansible_distribution_version == “18.04”

Når du bruker AND-operatoren, må begge setningene være oppfylt for at oppgaven skal utføres.

Spillet ovenfor installerer Nginx på noder som kjører en Debian-familie av OS som er versjon 18.04. Selvfølgelig vil dette være Ubuntu 18.04.

Eksempel 3: Bruke OR-operatør med When

Med OR-operatoren utføres oppgaven hvis en av betingelsene er oppfylt.

---
- hosts: all

  tasks:
  - name: Install Nginx on Debian
     apt: name=nginx state=present
     when: ansible_os_family == “Debian” or
	      Ansible_os_family == “SUSE”

Avspillingen ovenfor installerer Nginx-nettservere på enten Debian eller SUSE-familien av OS eller begge.

MERK: Sørg alltid for å bruke det doble likhetstegnet == når du tester en tilstand.

Betingelser i løkker

Betingelser kan også brukes i en loop. Si for eksempel at du har en liste over flere pakker som må installeres på eksterne noder.

I spilleboken nedenfor har vi en matrise kalt pakker som inneholder en liste over pakker som må installeres. Disse oppgavene vil bli utført etter hverandre hvis den påkrevde klausulen er satt til True.

---
 - name: Install Software packages
    hosts: all
    vars:
	packages:
    • name: nginx
required: True
    • name: mysql
required: True
    • name: apache
required: False



   tasks:
    • name: Install “{{ item.name }}”on Debian
apt: 
 name: “{{ item.name }}”
 state: present 
When: item.required == True
loop: “{{ packages }}”  

Konfigurer feilhåndtering

Noen ganger mislykkes oppgaver når du kjører playbooks. La oss anta at du kjører 5 oppgaver på 3 servere som vist i spilleboken nedenfor. Hvis det oppstår en feil på oppgave 3 (Starter MySQL) på server 2, vil Ansible slutte å utføre de resterende oppgavene på server 2 og forsøke å fullføre de gjenværende oppgavene på resten av serverne.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   tasks:
- name: Install dependencies
<< some code >>

- name: Install MySQL database
<< some code >>

- name: Start MySQL
<< some code >>

- name: Install Nginx
<< some code >>

- name: Start Nginx
<< some code >>

Hvis du vil ha konsistens i utførelsen av spilleboken, for eksempel, stopp utførelsen av en spillebok, dersom en av serverne mislykkes, legg til alternativet.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   any_errors_fatal:  true
   tasks:

På denne måten, hvis en oppgave mislykkes på én server, vil Ansible stoppe kjøringen av hele spilleboken på alle serverne og avslutte.

Hvis du vil at spilleboken skal ignorere feilene og fortsette å utføre det gjenværende settet med oppgaver, bruker du alternativet ignore_errors: True.

---
 - name: Install Software packages
   hosts: server1, server2, server3
   tasks:
- name: Install dependencies
<< some code >>
     ignore_errors: True

Opprett Playbooks for å konfigurere systemer til en spesifisert tilstand

I denne delen ser vi på noen tilleggsalternativer som er tilgjengelige når du kjører en spillebok.

La oss begynne med Sjekk-modus eller Tørrløp. Alternativet for tørrkjøring eller sjekkmodus brukes når du kjører en spillebok for å sjekke om det vil oppstå feil og om det er endringer som vil bli gjort på de administrerte vertene. Den gjør imidlertid ingen endringer i de eksterne nodene.

For eksempel, for å tørke en spillebok kalt httpd.yml som installerer og starter Apache-nettserverkjøringen:

ansible-playbook httpd.yml --check

Det andre alternativet vi må se på er --start-at-task-alternativet. Dette brukes når du spesifiserer navnet på oppgaven som spilleboken skal begynne eller starte på.

La oss ta et eksempel: Spilleboken nedenfor staver ut 2 oppgaver: Den første avspillingen installerer Apache-nettserveren og den andre installerer htop-verktøyet.

---
 - name: Install httpd

   hosts: all
   tasks:
    yum:	 
name: httpd
     state: Installed

- name: Install htop

      yum:  
      name: htop
      state: started

Hvis du vil hoppe over å installere Apache webserver og i stedet installere htop-verktøyet, kjør:

ansible-playbook playbook.yml --start-at-task “Install htop”

Til slutt kan du merke oppgavene eller avspillingene dine ved å legge til tags-alternativet i spilleboken som vist. Dette kommer godt med når du har en ganske stor spillebok og du vil kjøre spesifikke oppgaver fra hele spilleboken.

---
 - name: Install httpd
   tags: Install and start
   hosts: all
   tasks:
    yum:	 
name: httpd
     state: Installed

   tags: Install

    • service: 
name: httpd
state: started
ansible-playbook playbook.yml -tags "Install"

For å utelate kodene, bruk --skip-tags alternativene som vist.

ansible-playbook playbook.yml --skip-tags "Install"
Konklusjon

I dette emnet tok vi deg gjennom de ofte brukte modulene i Ansible, hvordan du henter ut stdout fra kjøringen av en playbook for analyse, bruk av betingelser i playbook og hvordan du håndterer feil som kan oppstå når du kjører oppgaver. Til slutt oppsummerte vi konfigurasjonen av playbooks og hvordan du kan bruke tilleggsalternativer for å bestemme hvilke oppgaver som skal kjøres hvis du ikke har tenkt å kjøre hele playbook.