Nota

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:

Prerequisiti

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.

  1. Aprire un terminale sul Luna Desktop.

  2. Duplica il progetto linux-virt-labs GitHub.

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

  3. Passare alla directory di lavoro.

    cd linux-virt-labs/olam

  4. Installare le raccolte richieste.

    ansible-galaxy collection install -r requirements.yml

  5. 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"
olam_type: olae
EOF

  6. Creare un file di inventario.

    cat << EOF | tee hosts > /dev/null
localhost ansible_connection=local ansible_connection=local ansible_python_interpreter=/usr/bin/python3.6
EOF

  7. Implementa l'ambiente di laboratorio.

    ansible-playbook create_instance.yml -i hosts -e "@instances.yml"

    L'ambiente di laboratorio gratuito richiede la variabile extra ansible_python_interpreter per localhost perché installa il pacchetto RPM per Oracle Cloud Infrastructure SDK per Python. La posizione per l'installazione di questo pacchetto si trova sotto i moduli Python predefiniti del sistema in base alla versione di Oracle Linux in uso. L'utilizzo di una variabile di inventario evita di influire sulle riproduzioni in esecuzione su host diversi da localhost.

    La forma di distribuzione predefinita utilizza la CPU AMD. È possibile modificare la forma delle istanze passando una nuova definizione di variabile forma sulla riga di comando.

    Ad esempio: -e instance_shape="VM.Standard3.Flex"

    Analogamente, la versione predefinita dell'immagine Oracle Linux utilizza la variabile os_version definita nel file `default_vars.yml. È possibile modificare questo valore passando la versione principale di Oracle Linux dalla riga di comando.

    Ad esempio: -e os_version="9"

    Importante: attendere che il playbook venga eseguito correttamente e raggiungere il task di sospensione. In questa fase del playbook, l'installazione di Oracle Linux è completa e le istanze sono pronte. Nota la riproduzione precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce.

Scrivi la configurazione iniziale di Playbook

Molti playbook sfruttano variabili e file variabili contenenti coppie chiave-valore, consentendo ai task reali del playbook di essere dinamici mentre il codice rimane statico. Un playbook include variabili che diventano parte dei playbook durante il runtime, in cui il playbook utilizza i propri valori durante l'esecuzione dei task.

Oracle Linux Automation Engine consente di definire queste variabili in diverse posizioni, ognuna con un ordine di precedenza specifico. Le variabili a livello di Playbook vengono definite nel playbook 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.

  1. Aprire un nuovo terminale e connettersi al sistema ol-control-node tramite SSH.

    ssh oracle@<ip_address_of_instance>

  2. Verificare che il comando Oracle Linux Automation Engine sia disponibile.

    ansible --version

  3. Creare una directory di lavoro del progetto.

    mkdir -p ~/ol-playbook

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

    mkdir ~/ol-playbook/vars

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

  5. 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'].

  6. 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, organizzati all'interno della 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 qualsiasi modulo o raccolta richiesta 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.

  1. Creare un file dei requisiti.

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

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

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

  2. Creare un nuovo file di inventario nella directory del progetto.

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

  3. Passare alla directory di lavoro del progetto.

    cd ~/ol-playbook

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

  5. Eseguire il playbook.

    ansible-playbook -i inventory setup.yml -u opc

    Il comando dovrebbe essere eseguito correttamente e visualizzare il risultato modificato di ciascuna riproduzione.

Connessione all'host remoto

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

  1. Connettersi al sistema ol-host tramite SSH.

    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>

  2. Verificare l'installazione dei pacchetti richiesti.

    Dopo aver eseguito il login, è possibile verificare che il playbook abbia installato il pacchetto git.

    git --version

  3. Disconnettersi dall'host remoto.

    exit

Aggiungi un repository

Oracle Linux offre una piattaforma sicura, scalabile e affidabile per la distribuzione di 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 Oracle Linux fornisce dettagli sui numerosi repository offerti da Oracle.

  1. 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: Add the EPEL repository
    ansible.builtin.dnf:
      name: oracle-epel-release-el9
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'

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

  - name: Install the htop utility package
    ansible.builtin.dnf:
      name: htop
      enablerepo: ol9_developer_EPEL
      state: present
    when:
      - ansible_distribution == 'OracleLinux'
      - ansible_facts['distribution_major_version'] == '9'
EOF

    Questo playbook aggiunge diversi task all'interno del gioco definito. Il primo set aggiunge il repository EPEL ai repository software esistenti nell'istanza di Oracle Linux. Nel frattempo, il secondo set di riproduzioni installa il pacchetto htop sulla 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.

  2. Rieseguire la guida per eseguire le attività aggiuntive.

    ansible-playbook -i inventory setup.yml -u opc

    Il playbook termina con successo, visualizzando alcuni avvertimenti durante la corsa. È possibile ignorare questi avvisi per il momento, in quanto non influiscono sul playbook corrente. Nel playbook vengono riportati i task come correttamente completati con uno 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 si richiede la versione più recente di un pacchetto piuttosto che controllarne la presenza. Un ok indica il completamento del task e non richiede alcuna azione.

  3. Verificare l'installazione del repository e del pacchetto.

    ssh oracle@$REMOTE which htop

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

  5. Uscire dal programma htop digitando q.

Aggiunta, aggiornamento ed eliminazione di file e directory

  1. 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 parametri seguenti: absent, directory, file, hard, link e touch. Questi task utilizzano la directory, che crea il percorso della directory se non è già presente, e 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 task. Nelle esercitazioni precedenti, è stata introdotta la funzionalità di escalation dei privilegi become: per eseguire un task come utente 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. Pertanto, questo task viene eseguito come utente oracle ed eredita i valori predefiniti di tale utente.

  2. Eseguire la guida per eseguire le attività aggiuntive.

    ansible-playbook -i inventory setup.yml -u opc

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

  4. Aggiungi più file.

    Durante la configurazione del sistema, potrebbe essere necessario creare diversi file in una directory. Anziché utilizzare singole attività, è possibile creare più file in una directory come singola 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 l'elenco di items su cui eseguire il loop durante l'esecuzione di questo task. Mentre in questo esempio vengono utilizzati solo quattro nomi di file, è possibile creare l'elenco per tutto il tempo necessario.

  5. Eseguire la guida per eseguire le attività aggiuntive.

    ansible-playbook -i inventory setup.yml -u opc

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

  7. 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 an additional test.
      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. Il playbook utilizza in primo luogo ansible.builtin.command per generare il contenuto del file aggiornato in stdout e lo salva in memoria in una variabile register. Quindi utilizza il modulo ansible.builtin.debug per stampare il contenuto sullo schermo come parte dell'output del playbook. Il secondo task di debug illustra un metodo per limitare l'output a una parte specifica dell'output JSON del task precedente.

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

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

  10. Eseguire la guida per eseguire le attività aggiuntive.

    ansible-playbook -i inventory setup.yml -u opc

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

  12. Confermare la creazione del nuovo file e l'aggiunta dei nostri contenuti.

    ssh oracle@$REMOTE cat example/testing.txt

  13. Eliminare file e directory.

    Oltre a creare file e directory e aggiungere testo, Oracle Linux Automation Engine può anche eliminare questi elementi. Rimuoviamo la directory e tutti i file che questo playbook crea, lasciando il sistema nello stesso stato di quando abbiamo iniziato. Per eseguire queste operazioni, utilizzare prima il parametro state: impostato su absent per rimuovere l'elenco dei file, quindi la directory. La seconda attività si occupa della rimozione dei file e della directory in un unico passaggio. 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, l'eliminazione dei file singolarmente, è disponibile se si desidera eliminare solo file specifici. Se si desidera eliminare sia i file che i file e le directory, la seconda attività è più efficiente.

  14. Eseguire la guida per eseguire le attività aggiuntive.

    ansible-playbook -i inventory setup.yml -u opc

  15. Verificare la rimozione della directory specificata.

    ssh oracle@$REMOTE ls

    La mancanza di output conferma che la directory specificata e i file creati durante questa esercitazione non sono più presenti.

Passi successivi

Complimenti per averlo fatto così lontano. Questa esercitazione ha introdotto diversi modi in cui Oracle Linux Automation Engine consente l'automazione delle attività di routine su Oracle Linux, tra cui 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 dimostrato come utilizzare il modulo ansible.builtin.debug di Oracle Linux Automation Engine per visualizzare le informazioni sul 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.