Nota

Questa esercitazione è disponibile in un ambiente di esercitazione pratica gratuito fornito da Oracle.
Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Al termine del laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.

Esegui le attività di Oracle Linux con Oracle Linux Automation Engine

Introduzione

Oracle Linux Automation Engine consente agli amministratori di automatizzare la configurazione iniziale di Oracle Linux ed eseguire altri processi amministrativi utilizzando uno strumento di gestione della configurazione Infrastructure as code (IaC) attraverso una serie di playbook e attività.

Obiettivi

In questo tutorial imparerai come:

Scrivi i playbook che:
- Crea un utente
- Aggiunge l'utente al gruppo sudo
- Copia una chiave pubblica SSH locale nel file authorized_keys dell'utente.
- Aggiunge un repository DNF e installa un pacchetto
- Manipola i file

Prerequisiti

Almeno due sistemi Oracle Linux con la seguente configurazione:
- un utente non root con autorizzazioni sudo
- coppia di chiavi ssh per l'utente non root
- la possibilità di SSH da un host a un altro utilizzando un login SSH senza password

Distribuisci Oracle Linux Automation Engine

Nota: se è in esecuzione nella propria tenancy, leggere il progetto linux-virt-labs GitHub README.md e completare i prerequisiti prima di distribuire l'ambiente di esercitazione pratica.

Aprire un terminale sul Luna Desktop.

Duplica il progetto linux-virt-labs GitHub.

git clone https://github.com/oracle-devrel/linux-virt-labs.git

Passare alla directory di lavoro.
```
cd linux-virt-labs/olam
```

Installare le raccolte richieste.

ansible-galaxy collection install -r requirements.yml

Aggiornare la configurazione dell'istanza Oracle Linux.

cat << EOF | tee instances.yml > /dev/null
compute_instances:
  1:
    instance_name: "ol-control-node"
    type: "control"
  2:
    instance_name: "ol-host"
    type: "remote"
use_olae_only: true
EOF

Implementa l'ambiente di laboratorio.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e "@instances.yml"
```
L'ambiente di laboratorio gratuito richiede la variabile aggiuntiva local_python_interpreter, che imposta ansible_python_interpreter per le riproduzioni in esecuzione su localhost. Questa variabile è necessaria perché l'ambiente installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python, situato sotto i moduli python3.6.

La forma di distribuzione predefinita utilizza la CPU AMD e Oracle Linux 8. Per utilizzare una CPU Intel o Oracle Linux 9, aggiungere -e instance_shape="VM.Standard3.Flex" o -e os_version="9" al comando di distribuzione.

Importante: attendere la corretta esecuzione della guida e raggiungere il task di sospensione. In questa fase del playbook, l'installazione di Oracle Linux è completa e le istanze sono pronte. Prendi nota della riproduzione precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce e qualsiasi altra informazione di distribuzione necessaria durante l'esecuzione del laboratorio.

Scrivi la configurazione iniziale di Playbook

Molti playbook sfruttano variabili e file variabili contenenti coppie chiave-valore, consentendo alle attività effettive del playbook di essere dinamiche mentre il codice rimane statico. Una playbook include le variabili durante il runtime, in cui i relativi valori diventano parte delle riproduzioni durante l'esecuzione delle attività.

Oracle Linux Automation Engine consente di definire queste variabili in diverse posizioni, ognuna con un ordine di precedenza. Le variabili a livello di Playbook vengono definite nella guida utilizzando la direttiva vars o vars_files. La direttiva vars specifica le variabili come parte della riproduzione, mentre la direttiva vars_files include un file esterno contenente le variabili. Gli sviluppatori possono creare queste variabili in modo dinamico o statico da un altro gioco, come faremo in questo esempio, che definisce la configurazione del sistema prima di eseguire il playbook.

Aprire un nuovo terminale e connettersi tramite SSH al sistema ol-control-node.
```
ssh oracle@<ip_address_of_instance>
```
Verificare che il comando Oracle Linux Automation Engine sia disponibile.
```
ansible --version
```
Creare una directory di lavoro del progetto.
```
mkdir -p ~/ol-playbook
```

Creare una directory e un file di variabili per il progetto.

mkdir ~/ol-playbook/vars

touch ~/ol-playbook/vars/defaults.yml

Aggiungere le variabili e i valori al file.
```
   
cat << EOF | tee ~/ol-playbook/vars/defaults.yml > /dev/null
---
username: oracle
user_default_password: oracle
ssh_key_file: id_rsa
ssh_private_key_file: "{{ lookup('file', lookup('env','HOME') + '/.ssh/' + ssh_key_file + '.pub') }}"
additional_packages: ['git']
EOF
   
```
Queste informazioni spiegano ogni variabile e come la useremo:
- username: il nome dell'utente sudo creato durante l'esecuzione della guida. In questo esempio, il nome dell'utente sarà oracle.
- user_default_password: la password predefinita per l'utente oracle al momento della creazione. La password è obbligatoria quando si eseguono i comandi sudo.
- ssh_key_file: imposta il nome della coppia di chiavi SSH dell'utente.
- ssh_private_key_file: copia la chiave pubblica SSH dell'utente nel file authorized_key dell'utente remoto nel percorso specificato. In questo esempio viene utilizzato il plugin lookup per trovare la chiave pubblica id_rsa.pub nella directory degli utenti locali $HOME/.ssh/.
- additional_packages: aggiungere il nome di eventuali pacchetti aggiuntivi da installare in formato array. Ogni pacchetto nell'array deve essere racchiuso tra virgolette singole e separato da una virgola. Se si installa un modulo appstream come container-tools, l'array avrà l'aspetto ['git',' @container-tools:ol8'].

Creare il file playbook.

   
cat << EOF | tee ~/ol-playbook/setup.yml > /dev/null
---
- hosts: all
  become: yes
  vars_files:
    - vars/defaults.yml

  tasks:

  - name: Generate new ssh keypair
    community.crypto.openssh_keypair:
      path: "~/.ssh/{{ ssh_key_file }}"
      size: 2048
      comment: olam ssh keypair
    become: true
    become_user: "{{ username }}"
    delegate_to: localhost

  - name: Add a user account with access to sudo
    ansible.builtin.user:
      name: "{{ username }}"
      password: "{{ user_default_password | password_hash('sha512') }}"
      comment: Default Oracle user
      groups: wheel
      append: yes
      update_password: on_create

  - name: Set the authorized key for the user using a local public key file
    ansible.posix.authorized_key:
      user: "{{ username }}"
      state: present
      key: "{{ ssh_private_key_file }}"

  - name: install additional packages
    ansible.builtin.dnf:
      name: "{{ additional_packages }}"
      state: latest
EOF
   

Le attività specifiche di un playbook e i nomi dei moduli mirano a rendere il playbook auto-documentante. Questi elementi indicano dove e chi gestisce i giochi:

hosts: all: questa riga specifica gli host dell'inventario che eseguiranno i task.
become: yes: indica ai task di questa sezione di essere eseguiti con il privilegio sudo per impostazione predefinita.
vars_files" Questa direttiva carica il file delle variabili contenente la configurazione del playbook di questa esercitazione.

Installa le raccolte richieste

Il pacchetto ansible-core contiene un set minimo di moduli per la gestione degli host denominati raccolta ansible.builtin. Una raccolta è un metodo per la distribuzione di playbook, ruoli, moduli o plugin che eseguono un task mirato. ansible-core richiede il download e l'installazione di moduli o raccolte necessari al di fuori dei built-in.

Poiché la guida precedente utilizza la raccolta ansible.posix, è necessario installare questa raccolta e altre. Il modo più semplice per farlo è creare un file dei requisiti che contenga tutte le dipendenze.

Creare un file dei requisiti.

cat << 'EOF' | tee ~/ol-playbook/requirements.yml > /dev/null
---
collections:
  - name: ansible.posix
  - name: community.crypto
EOF

Installare la raccolta.
```
ansible-galaxy collection install -r ~/ol-playbook/requirements.yml
```
L'output mostra il processo di recupero del file di archivio compresso dal sito Galaxy e quindi di installazione nella directory home in .ansible/collections.
Nota: se l'output mostra ERROR: Ansible requires the locale encoding to be UTF-8; Detected None., indica un'impostazione delle impostazioni nazionali errata per ansible. Risolvere il problema impostando le due variabili di ambiente riportate di seguito.
```
export LC_ALL="en_US.UTF-8"
export LC_CTYPE="en_US.UTF-8"
```

Esegui il Playbook

Prima di eseguire la guida, dobbiamo creare un file di inventario per questo progetto che punti all'istanza remota di Oracle Linux che intendiamo gestire.

Assegnare l'indirizzo IP dell'OL-host a una variabile per il nostro sistema remoto.

Questa variabile semplifica la creazione di script del file di inventario.
```
export REMOTE=<ip_address_of_instance>
```

Creare una nuova directory di progetto del file di inventario.

cat << EOF | tee ~/ol-playbook/inventory > /dev/null
[production]
ol-host ansible_host=$REMOTE
EOF

Passare alla directory di lavoro del progetto.
```
cd ~/ol-playbook
```
Eseguire il test della connessione con il comando ping ad hoc.
```
ansible ol-host -i ~/ol-playbook/inventory -m ping -u opc
```
- -u: passa il nome utente per la connessione ssh. Nell'ambiente di laboratorio gratuito, utilizziamo l'utente opc, l'utente predefinito fornito sulle istanze di Oracle Linux in Oracle Cloud Infrastructure (OCI). Approvare l'impronta digitale del tasto ECDSA digitando yes al prompt per continuare.
Il comando viene eseguito correttamente con risultati simili a quelli mostrati.
Output di esempio:
```
ol-host | SUCCESS => {
    "ansible_facts": {
        "discovered_interpreter_python": "/usr/bin/python"
    },
    "changed": false,
    "ping": "pong"
}
```
Eseguire il playbook.
```
ansible-playbook -i inventory setup.yml -u opc
```
Il comando dovrebbe essere eseguito correttamente, mostrando il risultato di ciascuna riproduzione changed.

Connessione all'host remoto

Se la guida viene eseguita correttamente, è possibile connettersi al sistema remoto con l'utente come definito nella variabile nome utente.

Connettersi tramite SSH al sistema ol-host.
```
ssh oracle@$REMOTE
```
Se si modifica il valore della variabile ssh_key_file, è necessario passare l'opzione `-i' a ssh, puntando al file di chiavi private della coppia specificata.
Esempio:
```
ssh -i ~/.ssh/<local_ssh_private_key> <username>@<ip_address_of_host>
```
Verificare l'installazione dei pacchetti richiesti.

Dopo aver eseguito il login, è possibile verificare che il playbook abbia installato il pacchetto git.
```
git --version
```
Disconnettersi dall'host remoto.
```
exit
```

Aggiungi un repository

Oracle Linux offre una piattaforma sicura, scalabile e affidabile in cui distribuire le applicazioni mission-critical. L'aggiunta di un repository aggiuntivo viene utilizzata per installare un nuovo prodotto Oracle o un'applicazione di terze parti. Oracle Linux fornisce pacchetti supplementari che gestiscono il provisioning di questi repository aggiuntivi.

Il server YUM di Oracle Linux fornisce i dettagli dei numerosi repository forniti da Oracle.

Aggiungere queste attività aggiuntive al file di playbook esistente.
```
cat << EOF | tee -a setup.yml > /dev/null
  - name: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el8
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol8_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '8'
EOF
```
Questo playbook aggiunge due compiti all'interno del gioco definito. Il primo aggiunge il repository EPEL ai repository software esistenti nell'istanza di Oracle Linux. Nel frattempo, il secondo play installa il pacchetto htop nella stessa istanza host di destinazione.

Parametri da notare:
- state: present: garantisce che il pacchetto a cui si fa riferimento sia già presente nel sistema o che venga installato utilizzando dnf.
- enablerepo: abilita il repository specifico (se disabilitato) solo per la durata del task corrente.
Rieseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
Il playbook termina con successo, mostrando alcuni avvertimenti che possiamo ignorare. La guida riporta i task completati correttamente con lo stato ok o changed. Lo stato changed indica che la playbook ha modificato l'host aggiungendo il pacchetto htop o aggiornando la cache dnf quando ha richiesto l'ultima versione di un pacchetto, invece di limitarsi a controllare se è presente. Un ok indica il completamento del task e non richiede alcuna azione.
Verificare l'installazione del repository e del pacchetto.
```
ssh oracle@$REMOTE which htop
```
Eseguire il comando htop.
```
ssh oracle@$REMOTE -t htop
```
L'opzione -t del comando SSH forza un'allocazione TTY perché htop richiede una shell interattiva.
Uscire dal programma htop digitando q.

Aggiunta, aggiornamento ed eliminazione di file e directory

Creare una directory e un file aggiungendo quanto segue al file di playbook esistente.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Create an example directory (if it does not already exist)
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: directory
      mode: '0755'
    become_user: "{{ username }}"

  - name: Create an empty file
    ansible.builtin.file:
      path: "/home/{{ username }}/example/test.txt"
      state: touch
      # mode: u=rw,g=r,o=r
    become_user: "{{ username }}"
EOF
   
```
Questo playbook aggiunge due compiti all'interno del gioco definito. La prima crea una nuova directory denominata esempio nella directory home dell'utente remoto, mentre la seconda crea un file vuoto denominato test.txt nella directory esempio appena creata.

Ulteriori parametri da notare:
- state:: il modulo ansible.builtin.file supporta i seguenti parametri: absent, directory, file, hard, link e touch. Per queste attività viene utilizzata la directory, che crea il percorso della directory se non è già presente, e la touch, che crea un file vuoto se non è già presente.
- mode: imposta le autorizzazioni del file system per l'oggetto creato. Quando si utilizza la riga di comando, è possibile utilizzare la modalità 0644 ottale o u=rw,g=r,o=r simbolica. Se il parametro mode: viene omesso, viene applicata la modalità predefinita del sistema.
- become_user: "": utilizza la funzionalità di escalation dei privilegi di Oracle Linux Automation Engine per eseguire un'attività. Nelle esercitazioni precedenti è stata introdotta la funzionalità di escalation dei privilegi become: per eseguire un task come root. In questo esempio viene illustrato come utilizzare funzionalità simili per eseguire un task come un altro utente. L'utente viene impostato come variabile "", predefinita come utente oracle nel file vars/defaults.yml. Di conseguenza, questo task viene eseguito come utente oracle ed eredita le impostazioni predefinite dell'utente.
Eseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
Verificare che la nuova directory e il nuovo file esistano sull'host remoto.
```
ssh oracle@$REMOTE ls -al example
```
L'output conferma la creazione di una nuova directory e del file vuoto. Si noti che il file test.txt ha zero byte e che l'utente oracle ne è proprietario.
Aggiungi più file.

Durante la configurazione di un sistema, potrebbe essere necessario creare diversi file all'interno di una directory. Anziché utilizzare singole attività, è possibile creare diversi file in una directory come operazione atomica.
```
   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add multiple files
    ansible.builtin.file:
      path: "/home/{{ username }}/example/{{ item }}"
      state: touch
    with_items:
    - file01.txt
    - file02.txt
    - file03.txt
    - file04.txt
    become_user: "{{ username }}"
EOF
   
```
Questo task utilizza un loop per creare diversi file vuoti da un elenco.
- path:: definisce la posizione sul sistema remoto in cui scrivere i file. Oracle Linux Automation Engine sostituisce la variabile `` con ciascun parametro item del parametro with_items durante il runtime.
- with_items:: questo parametro indica la lista di items su cui eseguire il loop durante l'esecuzione di questo task. In questo esempio vengono utilizzati solo quattro nomi di file, ma è possibile creare l'elenco per tutto il tempo necessario.
Eseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
Verificare che la nuova directory e il nuovo file esistano sull'host remoto.
```
ssh oracle@$REMOTE ls -al example
```
L'output mostra il file test.txt originale e i nuovi.

Aggiungere una singola riga di contenuto a un file.

   
cat << 'EOF' | tee -a setup.yml > /dev/null     

  - name: Insert some text into the test.txt file
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      line: This is a test
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Add an extra line after the line just inserted
    ansible.builtin.lineinfile:
      path: "/home/{{ username }}/example/test.txt"
      regexp: '^a test'
      insertafter: 'This is a test'
      line: This is some updated text that was added later.
      create: True
      owner: "{{ username }}"
      group: "{{ username }}"
      mode: '0644'

  - name: Get the contents of the test.txt file
    ansible.builtin.command: cat ~/example/test.txt
    register: command_output
    become_user: "{{ username }}"

  - name: Print the results of the cat command
    ansible.builtin.debug:
      msg: "{{ command_output }}"

  - name: Print only the lines added to the text file
    ansible.builtin.debug:
      msg: "{{ command_output.stdout_lines }}"
EOF
   

Le prime due attività utilizzano ansible.builtin.lineinfile per aggiungere e aggiornare singole righe nel file.
I task rimanenti mostrano un metodo per confermare le modifiche. La guida utilizza innanzitutto ansible.builtin.command per eseguire l'output del contenuto del file aggiornato su stdout e lo salva in memoria in una variabile register. Il modulo ansible.builtin.debug viene quindi utilizzato per stampare il contenuto sullo schermo come parte dell'output della guida. Il secondo task di debug mostra un modo per limitare l'output solo a una parte particolare dell'output JSON del task precedente.

Eseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
L'ultima attività della guida stampa il contenuto del file utilizzando il modulo debug.

Aggiungere più righe di contenuto a un file.

   
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Add two lines into test.txt
    ansible.builtin.blockinfile:
      path: "/home/{{ username }}/example/test.txt"
      insertafter: 'This is some updated text that was added later.'
      block: |
        "Welcome to {{ ansible_hostname }}"
        "Last updated on {{ ansible_date_time.iso8601 }}"

  - name: Create a new file and insert content into it
    ansible.builtin.copy:
      content: |
        === The text below was added by Oracle Linux Automation Engine ==========

        Hello from the ansible.builtin.copy module.
        This task is an example of inserting multiple lines into a text file.
        You can insert more lines if you want.

        === The text above was added by Oracle Linux Automation Engine ===========
      dest: "/home/{{ username }}/example/testing.txt"
      mode: '0644'
    become_user: "{{ username }}"
EOF
   

Eseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
Confermare la presenza di due nuove righe nel file.
```
ssh oracle@$REMOTE cat example/test.txt
```
L'output mostra il contenuto aggiunto e interpreta i valori variabili dell'attività in base alla raccolta automatica dei fatti eseguita dalla playbook contro l'host remoto durante il runtime.
Confermare la creazione del nuovo file e l'aggiunta del contenuto.
```
ssh oracle@$REMOTE cat example/testing.txt
```
Eliminare file e directory.

Oltre a creare file e directory e ad aggiungere testo, Oracle Linux Automation Engine può anche eliminare questi elementi. Rimuoviamo la directory e tutti i file creati da questo playbook e lasciamo il sistema nello stesso stato di quando abbiamo iniziato. Per queste attività, usare prima il parametro state: impostato su absent per rimuovere l'elenco dei file, quindi la directory. La seconda attività gestisce la rimozione dei file in un unico passaggio insieme alla directory. Tuttavia, includiamo il primo task per una dimostrazione aggiuntiva delle funzionalità di Oracle Linux Automation Engine.
```
    
cat << EOF | tee -a setup.yml > /dev/null     

  - name: Delete multiple files
    ansible.builtin.file:
      path: '{{ item }}'
      state: absent
    with_items:
      - "/home/{{ username }}/example/test.txt"
      - "/home/{{ username }}/example/file01.txt"
      - "/home/{{ username }}/example/file02.txt"
      - "/home/{{ username }}/example/file03.txt"
      - "/home/{{ username }}/example/file04.txt"
      - "/home/{{ username }}/example/testing.txt"

  - name: Recursively remove directory
    ansible.builtin.file:
      path: "/home/{{ username }}/example"
      state: absent
EOF
    
```
È possibile eliminare in modo ricorsivo una directory e qualsiasi contenuto utilizzando la seconda attività mostrata. Il primo task, eliminando i file singolarmente, è presente nel caso in cui si desidera eliminare solo i file. Se si desidera eliminare sia i file che i file e le directory, la seconda attività è più efficiente.
Eseguire la guida per eseguire le attività aggiuntive.
```
ansible-playbook -i inventory setup.yml -u opc
```
Verificare la rimozione della directory specificata.
```
ssh oracle@$REMOTE ls
```
La mancanza di output conferma la directory specificata e i file creati durante questo tutorial sono andati.

Passi successivi

Complimenti per averlo fatto fino a questo punto. Questa esercitazione ha introdotto diversi modi in cui Oracle Linux Automation Engine rende possibile l'esecuzione di attività di routine su Oracle Linux tramite l'automazione, ad esempio l'installazione di pacchetti, la creazione, l'aggiornamento e l'eliminazione di file e directory, nonché l'aggiunta di account utente a Oracle Linux. Abbiamo anche mostrato come utilizzare il modulo ansible.builtin.debug di Oracle Linux Automation Engine per restituire informazioni al terminale durante l'esecuzione di un Playbook. Con queste abilità, hai un vantaggio per avventurarti in avanti e scrivere i tuoi playbook.

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.

Titolo e informazioni sul copyright

Run Oracle Linux Tasks with Oracle Linux Automation Engine

F49866-05