Hvordan bruke løkker i Ansible

Når du jobber med kode, kan det hende du må utføre en kodeblokk flere ganger. Å skrive den samme kodeblokken igjen og igjen er overflødig og ansett som dårlig design. Det er her løkker kommer inn.

Løkker er sett med kommandoer eller instruksjoner som er satt til å gjenta et visst antall ganger per brukerkrav. Løkker gir bedre kontrollstrøm i skriptene dine og fjerner generell redundans fra dem.

Ansible kommer også med flere metoder for sløyfeblokker med kode. Denne guiden er ment å hjelpe deg å lære om løkker i Ansible. Vi vil dekke det grunnleggende om looping i Ansible, sammen med syntaks og passende eksempler.

Når det er sagt, la oss se på løkker i Ansible.

Nøkkelord for løkker i Ansible

Ansible bruker følgende nøkkelord for sine sløyfestrukturer:

• "Løkke"
• "med_"
• "før"

Som navnet antyder, er "loop" -kommandoen for å implementere løkker i kodeblokker.

I likhet med “Loop” har du “med_”. Denne kommandoen krever at du gir den et oppslagsplugin. Det anbefales å bruke med_* i stedet for sløyfe når oppslagsplugger er involvert.

“Inntil” lar deg fortsette å utføre en oppgave til den nødvendige tilstanden er oppfylt. Det er nærmest "mens" -tilstanden i kontrollstrømmen.

Nå som du har en ide om nøkkelordene for løkker, kan du fortsette å lære om hvordan du implementerer dem i kode.

Standard løkker i Ansible

Vi starter med å diskutere hvordan du implementerer standardløkker i Ansible. For standardløkker bruker vi "med_" nøkkelordet.

Dette eksemplet demonstrerer hvordan vi kan bruke løkker for å legge til brukere.

- Navn: Legg til flere brukere
bruker:
Navn: "item"
Stat: Nåværende
Grupper: "Wheel"
med_items:
- VM1
- VM2

Nå ville neste trinn være å kjøre spillboken. Du kan gjøre det ved hjelp av følgende kommando i Linux -terminalen:

Ansible-Playbook Testbook.yml

Her er "element" oppslagstegnet. “With_item” har henholdsvis to verter, VM1 og VM2. Løkken gjør det samme som koden nedenfor:

- Navn: Legg til bruker VM1
bruker:
Navn: "VM1"
Stat: Nåværende
Grupper: "Wheel"
- Navn: Legg til bruker VM2
bruker:
Navn: "VM2"
Stat: Nåværende
Grupper: "Wheel"

Som du kan se, ved å bruke "with_item", kan vi fjerne redundans fra koden vår. Ved å legge til flere brukere under “With_items:”, kan vi legge til flere brukere i henhold til behov.

Det neste eksemplet vil dekke hvordan du utfører nestede løkker i Ansible.

Nestede løkker i Ansible

Ansible lar deg implementere nestede løkker i skriptene sine. Et eksempel på en slik sløyfe er gitt nedenfor.

- Navn: Gir brukere tilgang til databaser
mysql_user:
Navn: "item [0]"
Priv: "item [1].*:ALLE"
Append_Privs: Ja
Passord: "Foo"
med_nestet:
- ['Linuxuser1', 'Linuxuser2']
- ['Klient', 'ansatt', 'leverandør']

Alternativt kan du skrive den samme koden med "loop" som følger:

- Navn: Gir brukere tilgang til databaser
samfunnet.mysql.mysql_user:
Navn: "item [0]"
Priv: "item [1].*:ALLE"
Append_Privs: Ja
Passord: "Foo"
Loop: "['Linuxuser1', 'Linuxuser2'] | Produkt (['Client', 'Employee', 'Provider'])) | liste"

Brukerne vil få tilgang til alle databaser en etter en. Som nevnt tidligere, er det lettere å forstå at "med_" er bedre med oppslagsplugins i stedet for "loop" som syntaks.

La oss ta en titt på noen andre eksempler som fremhever muligheten til Ansible.

Bruker ansibelen for å iterere over hashes

Ansible lar deg sløyfe over en liste over hasj. Dette kan sees fra eksemplet gitt nedenfor.

La oss anta at du har erklært en liste over brukere som følger.

Brukere:
VM1:
Navn: Virtuell maskin 1
Seriell: 00000001
VM2:
Navn: Virtual Machine 2
Seriell: 00000002

For å skrive ut alle navn og serier, utfør skriptet nedenfor.

oppgaver:
- Navn: Skriv ut brukerinfo
Debug:
MSG: "Bruker element.nøkkel er element.verdi.name (element.verdi.Serial) "
med_dict: "brukere"

Dette vil skrive ut henholdsvis brukernavn og serier. Ved å legge til flere brukere i "brukere:" -panelet, kan du skrive ut flere brukere uten å måtte skrive koden igjen.

Bruke løkker for parallelle datasett

Du kan også bruke løkker for parallelle sett med data. Dette er demonstrert i eksemplet nedenfor:

La oss anta at du har følgende data:

Alfabeter: ['A', 'B', 'C', 'D']

Num: [2, 4, 6, 8]

Du kan sløyfe disse kommandoene som følger:

oppgaver:
- Debug:
msg: "element.0 og element.1 "
med_together:
- "alfabet"
- "num"

Ovennevnte kode vil sløyfe begge sett med data sammen som (a, 2), (b, 4), etc.

Tilfeldig valgløkker

En av funksjonene som følger med "med_" -løkker er "random_choice".

Som navnet antyder, brukes den tilfeldige valgfunksjonen til å velge elementer tilfeldig fra et gitt sett med instruksjoner.

Dette eksemplet illustrerer hvordan du lager løkker for å velge en handling fra en gitt liste over strenger.

- Debug:
msg: "item"
med_random_choice:
- "Utfør handling 1"
- "Utfør handling 2"
- "Utfør handling 3"
- "Utfør handling 4"

Her er "utfør handling" -strengen vilkårlig og kan erstattes med hva som helst. Kommandoen med_random_choice vil velge fra den gitte listen over handlinger tilfeldig.

“Inntil” Loop -eksempler

Denne delen av guiden vil handle om "til" sløyfesyntaks.

Som nevnt tidligere, vil "til" -kommandoen gjenta et visst sett med instruksjoner til den oppfyller en viss tilstand.

Her er et eksempel på "til" -løkken i aksjon.

Shell:/usr/bin/foo

Register: Resultat

Inntil: Resultat.stdout.finn ("alle systemer klare") != -1

Forsøk: 10

Forsinkelse: 7

Dette er et eksempel på en rekursiv sløyfe. Ovennevnte kodeblokk vil fortsette å kjøre til skallet mottar “alle systemer klare” som tekstutgang. Hvis det ikke er tilfelle, vil det stoppe etter å ha kjørt 10 ganger ettersom de spesifiserte forsøkene er "10".

Forsinkelsen tilsvarer forsinkelsen i sekunder. Som standard er den satt til 5.

Konklusjon

Dette var en guide for hvordan du kan bruke løkker i Ansible. Vi dekket det grunnleggende om løkker og deres syntaks i Ansible, og demonstrerte bruken av dem via forskjellige eksempler. Med dette håper vi at du er et skritt nærmere å automatisere prosessene dine ved hjelp av Ansible.