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.

Usa un inventario dinamico OCI con Oracle Linux Automation Engine

Introduzione

Oracle Linux Automation Engine, un software open source per la gestione del provisioning e della configurazione, utilizza un file di inventario per operare su nodi gestiti o host all'interno della tua infrastruttura. Questo file di inventario contiene un elenco di server, i relativi indirizzi IP e altre informazioni di connessione facoltative.

Un file di inventario statico funziona bene se l'infrastruttura non cambia.

Tuttavia, la tua infrastruttura è probabilmente in costante cambiamento quando utilizzi il cloud. Pertanto, sarebbe utile che l'inventario venga aggiornato dinamicamente man mano che gli host vengono aggiunti e rimossi.

Obiettivi

In questo tutorial imparerai a:

Imposta Oracle Linux Automation Engine
Crea un inventario dinamico OCI
Utilizza l'inventario dinamico OCI con una guida

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"
olam_type: none
EOF

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

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.

Impostare il nodo di controllo di Oracle Linux Automation Engine

Il nodo di controllo è il sistema per eseguire le playbook di Oracle Linux Automation Engine. L'esecuzione dei playbook richiede l'installazione del pacchetto Oracle Linux Automation Engine.

Impostare una variabile uguale all'indirizzo IP del nodo di controllo.
```
export CONTROL="<ip_address_of_ol-control-node>"
```
Aprire un terminale e copiare la coppia di chiavi SSH nel nodo di controllo.
```
scp -rp ~/.ssh/id_rsa* oracle@$CONTROL:~/.ssh/
```
Impostare le autorizzazioni per la chiave privata SSH.
```
ssh oracle@$CONTROL "chmod 600 ~/.ssh/id_rsa"
```
Connettersi al sistema ol-control-node tramite SSH.
```
ssh oracle@$CONTROL
```
Installare il pacchetto Oracle Linux Automation Engine e le dipendenze.
```
sudo dnf install -y ansible-core
```
Il pacchetto ansible-core è disponibile nel repository AppStream.
Eseguire il test dell'installazione del pacchetto.
```
ansible --version
```
Rivedere l'output e cercare la versione predefinita di Oracle Linux Automation Manager Python. Questo è l'ambiente in cui dobbiamo installare l'SDK Oracle Cloud Infrastructure (OCI) per Python.
Nota: se l'output mostra ERRORE: Ansible richiede che la codifica delle impostazioni nazionali sia UTF-8; nessuna rilevata. 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"
```

Installare Oracle Cloud Infrastructure SDK per Python

Il plugin OCI Dynamic Inventory richiede un SDK OCI di lavoro per la configurazione Python nel nodo di controllo. Possiamo installare l'SDK OCI utilizzando l'RPM o PIP di Oracle Linux, il programma di installazione del pacchetto per Python.

Installare l'SDK OCI per Python utilizzando PIP.
1. Installare i pacchetti e le dipendenze per il PIP.
  
  Oracle Linux 8:
```
sudo dnf install -y python3.12-pip python3.12-setuptools
```
  Oracle Linux 9:
```
sudo dnf install -y python3.9-pip python3.9-setuptools
```
2. Installare i pacchetti Python
  
  Oracle Linux 8:
```
/usr/bin/python3.12 -m pip install oci
```
  Oracle Linux 9:
```
/usr/bin/python3.9 -m pip install oci
```
  Aggiungere l'opzione --proxy se si è dietro un proxy. I dettagli sono disponibili nella Guida mediante l'esecuzione del comando python3.12 -m pip help install.
Eseguire il test dell'SDK OCI per l'installazione Python stampandone la versione.

Oracle Linux 8:
```
python3.12 -c "import oci;print(oci.__version__)"
```
Oracle Linux 9:
```
python3.9 -c "import oci;print(oci.__version__)"
```
Creare la directory di configurazione predefinita dell'SDK OCI.
```
mkdir -p ~/.oci
```
Creare il file di configurazione predefinito dell'SDK

Il laboratorio gratuito fornisce una configurazione SDK pre-generata, che possiamo copiare nel sistema ol-control-node utilizzando scp.
1. Aprire un nuovo terminale dall'ambiente desktop.
2. Copiare tutti i file di configurazione SDK nel sistema ol-control-node.
```
scp ~/.oci/* oracle@<ip_address_of_instance>:~/.oci/.
```
```
exit
```
Se si sta seguendo questa esercitazione all'esterno dell'ambiente di laboratorio gratuito, vedere le istruzioni fornite nelle sezioni File di configurazione SDK e CLI e Chiavi e OCID obbligatori della documentazione OCI per generare il file di configurazione OCI.
Passare alla finestra del terminale collegata al sistema ol-control-node.
Aggiornare la posizione di key_file nel file di configurazione dell'SDK.

Quando si copia il file di configurazione SDK dall'ambiente desktop, è necessario modificare la parte della directory home dell'utente di key_file per assicurarsi che corrisponda al nome utente del sistema di controllo.
```
sed -i 's/luna.user/oracle/g' ~/.oci/config
```

Creare uno script Python di test per verificare che l'SDK funzioni.

cat << EOF | tee test.py > /dev/null
import oci
object_storage_client = oci.object_storage.ObjectStorageClient(oci.config.from_file())
result = object_storage_client.get_namespace()
print("Current object storage namespace: {}".format(result.data))
EOF

Lo script test.py visualizza lo spazio di nomi dello storage degli oggetti per la tenancy e il compartimento OCI configurati.

Eseguire lo script

Oracle Linux 8:
```
python3.12 test.py
```
Oracle Linux 9:
```
python3.9 test.py
```
Lo script di test stampa lo spazio di nomi univoco della tenancy configurata.

Installa la raccolta Oracle Cloud Infrastructure Ansible

La raccolta Ansible di OCI contiene un set di moduli che automatizzano il provisioning e la configurazione dell'infrastruttura cloud, orchestrano processi operativi complessi e distribuiscono e aggiornano gli asset software.

Creare una directory di progetto.
```
mkdir ~/myproject
```

Creare un file dei requisiti.

cat << EOF | tee ~/myproject/requirements.yml > /dev/null
---
collections:
  - name: oracle.oci
EOF

Installare la raccolta Ansible OCI.
```
ansible-galaxy collection install -r ~/myproject/requirements.yml
```
Se è stata installata una versione precedente, ottenere la release più recente eseguendo il comando con l'opzione --force.
```
ansible-galaxy collection install --force oracle.oci
```

Utilizzo di OCI Dynamic Inventory

Oracle include il plugin di inventario dinamico nella raccolta Ansible di OCI.

Configurare il plugin magazzino creando un'origine di configurazione YAML.

Il nome del file di origine deve essere <filename>.oci.yml o <filename>.oci.yaml. Dove <filename> è un identificatore utile definito dall'utente.
```
cat << EOF | tee ~/myproject/myproject.oci.yml > /dev/null
---
plugin: oracle.oci.oci

# Optional fields to specify oci connection config:
config_file: ~/.oci/config
config_profile: DEFAULT
EOF
```
Eseguire il test del plugin inventario creando un grafico inventario.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
L'output mostra una serie di avvertenze ed errori. Cosa è andato storto?

L'errore si è verificato perché il plugin richiede la conoscenza dell'OCID compartimento. Se si fornisce l'OCID della tenancy anziché l'OCID del compartimento e si dispone delle autorizzazioni corrette, il plugin genererà un inventario per l'intera tenancy.

Poiché il plugin non è in grado di leggere le informazioni sull'OCID del compartimento direttamente dal file di configurazione dell'SDK, aggiungerle al file di origine della configurazione del plugin.
Recuperare l'OCID del compartimento dal file di configurazione dell'SDK e assegnarlo alla variabile comp_ocid.
```
comp_ocid=$(grep -i compartment ~/.oci/config | sed -e 's/compartment-id=//g')
```
Aggiungere un parametro del compartimento al file di origine del plugin.
```
cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

compartments:
  - compartment_ocid: "$comp_ocid"
    fetch_compute_hosts: true
EOF
```
L'impostazione di fetch_compute_hosts su true determina la raccolta delle informazioni di inventario solo sugli host di computazione e ignora gli altri tipi di istanza distribuiti all'interno del compartimento.
Rieseguire il test.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
Il nostro esempio mostra le istanze di computazione disponibili all'interno del compartimento come elenco dei gruppi di inventario designati dal carattere @ e visualizza l'indirizzo IP pubblico dell'istanza.

E se volessimo l'indirizzo IP privato?

Il recupero dell'indirizzo IP privato è necessario in base alla posizione fisica del nodo del controller o alla topologia di rete configurata all'interno dell'infrastruttura cloud. Un altro motivo per ottenere l'indirizzo IP privato è quando le istanze di computazione richieste hanno solo un indirizzo IP privato.
Modificare il parametro del formato del nome host del plugin aggiornando il file di origine della configurazione del plugin.
```
cat << EOF | tee -a ~/myproject/myproject.oci.yml > /dev/null

hostname_format_preferences:
  - "private_ip"
  - "public_ip"
EOF
```
Il formato di esempio riportato sopra dà la priorità all'indirizzo IP privato di un sistema rispetto all'indirizzo IP pubblico. Per ulteriori dettagli su questa configurazione, vedere Hostname Format Preferences nella documentazione.
Ripetere il test del plugin.
```
ansible-inventory -i ~/myproject/myproject.oci.yml --graph
```
L'output ora visualizza l'indirizzo IP privato.

Esegui un Playbook

Con l'impostazione e la configurazione dell'inventario dinamico, possiamo usarlo per eseguire un semplice playbook. Assicurarsi di abilitare l'accesso SSH tra i nodi di controllo e qualsiasi nodo remoto.

Crea un playbook che esegue il ping sull'host.
```
cat << EOF | tee ~/myproject/ping.yml > /dev/null
---
- hosts: all,!$(hostname -i)
  tasks:
  - name: Ansible ping test
    ansible.builtin.ping:
EOF
```
Oracle Linux Automation Engine prevede una lista separata da virgole di host o gruppi dopo la voce - hosts: e ! indica che deve escludere tali voci. La voce all esegue il ping di ogni host visualizzato nell'inventario come @all all'interno del gruppo di livello superiore. È possibile modificare questa guida per utilizzare un gruppo diverso dall'output del grafico rimuovendo il carattere @ dal nome e immettendo tale nome nella voce - hosts:.
Eseguire il playbook.
```
ansible-playbook -u opc -i ~/myproject/myproject.oci.yml ~/myproject/ping.yml
```
Accettare l'impronta digitale della chiave ECDSA quando richiesto.

L'opzione -i consente di impostare il file di inventario dinamico utilizzato.

L'opzione -u imposta l'utente SSH remoto durante il tentativo di connessione.

Passi successivi

Il completamento dell'esecuzione della guida con stato ok conferma che Oracle Linux Automation Engine utilizza correttamente l'inventario dinamico OCI per comunicare con l'istanza remota rilevata all'interno del compartimento. Continua a imparare e usa questa funzione per gestire la tua flotta di istanze OCI ed eseguire attività di amministrazione di routine su Oracle Linux.

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

Use an OCI Dynamic Inventory with Oracle Linux Automation Engine

F55851-03