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.

Eseguire la migrazione di Oracle Linux Automation Manager a una distribuzione in cluster

Introduzione

Sia che si tratti di un upgrade da una release precedente o di un avvio con una singola installazione host, entrambi gli ambienti possono eseguire la migrazione a una distribuzione in cluster. Gli amministratori devono pianificare la propria topologia prima di eseguire la migrazione, poiché il cluster può essere costituito da una combinazione di nodi Piano di controllo, Esecuzione e Hop e da un database remoto.

Dopo aver seguito questa esercitazione, sarà possibile eseguire la migrazione di un'installazione host singola a una distribuzione in cluster con un database remoto.

Obiettivi

In questo tutorial imparerai come:

Impostare un database remoto
Eseguire la migrazione a una distribuzione in cluster

Prerequisiti

Un sistema con Oracle Linux Automation Manager installato.

Per informazioni dettagliate sull'installazione di Oracle Linux Automation Manager, vedere il manuale Oracle Linux Automation Manager Installation Guide.

Distribuisci Oracle Linux Automation Manager

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: "olam-node"
    type: "control"
  2:
    instance_name: "exe-node"
    type: "execution"
  3:
    instance_name: "db-node"
    type: "db"
passwordless_ssh: true
add_cluster_ports: true
EOF

Implementa l'ambiente di laboratorio.
```
ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml" -e olam_single_host=true
```
L'ambiente di laboratorio gratuito richiede la variabile aggiuntiva ansible_python_interpreter perché installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python. La posizione dell'installazione di questo pacchetto si trova 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. L'installazione di Oracle Linux Automation Manager è stata completata in questa fase del playbook e le istanze sono pronte. Prendi nota della riproduzione precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce.

Eseguire il login a WebUI

Aprire un terminale e configurare un tunnel SSH per Oracle Linux Automation Manager.
```
ssh -L 8444:localhost:443 oracle@<hostname_or_ip_address>
```
Nell'ambiente di laboratorio gratuito, utilizzare l'indirizzo IP esterno dell'istanza olam-node.
Aprire un browser Web e immettere l'URL.
```
https://localhost:8444
```
Nota: approvare l'avvertenza di sicurezza in base al browser utilizzato. Per Chrome, fare clic sul pulsante **Avanzate, quindi sul collegamento Procedi a localhost (non sicuro).
Eseguire il login a Oracle Linux Automation Manager con Nome utente di admin e la Password di admin creata durante la distribuzione automatica.
Dopo aver eseguito il login, viene visualizzato il file WebUI.

Esegui migrazione a una distribuzione cluster

Oracle Linux Automation Manager viene eseguito come distribuzione host singolo, ma supporta anche l'esecuzione come cluster con un database remoto e un piano di controllo separato e nodi di esecuzione. L'installazione configura l'istanza del singolo host come nodo hybrid. Il primo passo per eseguire la migrazione a una distribuzione cluster consiste nella conversione di questa istanza in un nodo control plane.

Per ulteriori informazioni su diverse topologie di installazione, consultare il capitolo Planning the Installation della documentazione del manuale Oracle Linux Automation Manager Installation Guide.

Prepara nodo piano di controllo

Passare al terminale connesso all'istanza olam-node su cui è in esecuzione Oracle Linux Automation Manager.

Nota: d'ora in poi, si farà riferimento a questa istanza come nodo del piano di controllo.
Arrestare il servizio Oracle Linux Automation Manager.
```
sudo systemctl stop ol-automation-manager
```

Creare un backup del database.

sudo su - postgres -c 'pg_dumpall > /tmp/olamv2_db_dump'

Installare il database remoto

Copiare il backup del database dal nodo del piano di controllo nel nuovo host del database remoto.
```
scp /tmp/olamv2_db_dump oracle@db-node:/tmp/
```
Il comando scp comunica utilizzando una connessione SSH tra i nodi. Questa connessione è possibile a causa dell'ambiente di laboratorio gratuito che configura login SSH senza password tra le istanze.
Connettersi tramite ssh all'istanza db-node.
```
ssh oracle@db-node
```
Abilitare il flusso del modulo di database.

Oracle Linux Automation Manager consente l'uso del database Postgresql versione 12 o 13. Utilizzeremo e abiliteremo il flusso di moduli della versione 13 in questo tutorial.
```
sudo dnf -y module reset postgresql
sudo dnf -y module enable postgresql:13
```
Installare il database server.
```
sudo dnf -y install postgresql-server
```

Aggiungere la regola firewall database.

sudo firewall-cmd --add-port=5432/tcp --permanent
sudo firewall-cmd --reload

Inizializzare il database.
```
sudo postgresql-setup --initdb
```
Impostare l'algoritmo di memorizzazione predefinito del database.
```
sudo sed -i "s/#password_encryption.*/password_encryption = scram-sha-256/"  /var/lib/pgsql/data/postgresql.conf
```
Per ulteriori dettagli su questa funzionalità del database, vedere Autenticazione password nella documentazione a monte.
Aggiornare il file di autenticazione basato sull'host del database.
```
echo "host  all  all 0.0.0.0/0 scram-sha-256" | sudo tee -a /var/lib/pgsql/data/pg_hba.conf > /dev/null
```
Questa riga aggiuntiva esegue l'autenticazione SCRAM-SHA-256 per verificare la password di un utente durante la connessione da qualsiasi indirizzo IP.
Aggiornare il valore listen_address in cui il database ascolta le connessioni.
```
sudo sed -i "/^#port = 5432/i listen_addresses = '"$(hostname -s)"'" /var/lib/pgsql/data/postgresql.conf
```
È possibile scegliere l'indirizzo IP o il nome host per questo valore. L'esercitazione utilizza hostname -s per selezionare il nome host.
Avviare e abilitare il servizio di database.
```
sudo systemctl enable --now postgresql
```

Importare il file di dump del database.

sudo su - postgres -c 'psql -d postgres -f /tmp/olamv2_db_dump'

Impostare la password dell'account utente del database Oracle Linux Automation Manager.
```
sudo su - postgres -c "psql -U postgres -d postgres -c \"alter user awx with password 'password';\""
```
Questo comando imposta la password awx su password. Scegliere una password più sicura se si esegue questo comando al di fuori dell'ambiente di laboratorio gratuito.
Chiudere la sessione SSH connessa all'istanza db-node, in quanto completa i passi necessari per impostare il database remoto.
```
exit
```

Aggiungi impostazioni database remoto

Confermare la connessione all'istanza olam-node controllando il prompt del terminale.
Verificare che l'host possa comunicare con il database remoto.
```
pg_isready -d awx -h db-node -p 5432 -U awx
```
Il pacchetto postgresql include il comando pg_isready. Questo pacchetto fa parte dell'installazione originale di un singolo host. Se questo comando non funziona, è probabile che sia stato saltato un passo sopra o che manchi l'accesso in entrata alla porta 5432 sulla rete.

Aggiungere le impostazioni del database remoto a un nuovo file di configurazione personalizzato.

cat << EOF | sudo tee /etc/tower/conf.d/db.py > /dev/null
DATABASES = {
    'default': {
        'ATOMIC_REQUESTS': True,
        'ENGINE': 'awx.main.db.profiled_pg',
        'NAME': 'awx',
        'USER': 'awx',
        'PASSWORD': 'password',
        'HOST': 'db-node',
        'PORT': '5432',
    }
}
EOF

Utilizzare la stessa password impostata in precedenza per l'account utente del database awx.

Arrestare e disabilitare il database locale sul nodo del piano di controllo.
```
sudo systemctl stop postgresql
sudo systemctl disable postgresql
```
Maschera il servizio di database locale.
```
sudo systemctl mask postgresql
```
Questa operazione impedisce l'avvio del servizio di database locale all'avvio del servizio Oracle Linux Automation Manager.

Avviare Oracle Linux Automation Manager.

sudo systemctl start ol-automation-manager

Verificare che Oracle Linux Automation Manager si connetta al database remoto.
```
sudo su -l awx -s /bin/bash -c "awx-manage check_db"
```
Se una connessione riesce, l'output restituisce i dettagli della versione remota del database.

Rimuovi istanza di database locale

La rimozione del database locale originale è sicura dopo la conferma del funzionamento della connessione al database remoto.

Rimuovere i package di database.
```
sudo dnf -y remove postgresql
```
Rimuovere la directory pgsql contenente i vecchi file di dati del database.
```
sudo rm -rf /var/lib/pgsql
```

Modificare il tipo di nodo del nodo del piano di controllo

Quando si esegue la conversione in una distribuzione in cluster, passare dall'istanza a host singolo node_type a hybrid a control.

Confermare il tipo di nodo corrente del nodo del piano di controllo.
```
sudo su -l awx -s /bin/bash -c "awx-manage list_instances"
```
L'output mostra il valore node_type impostato su hybrid.

Rimuovere il gruppo di istanze predefinito.

sudo su -l awx -s /bin/bash -c "awx-manage remove_from_queue --queuename default --hostname $(hostname -i)"

Definire la nuova istanza e la nuova coda.

sudo su -l awx -s /bin/bash -c "awx-manage provision_instance --hostname=$(hostname -i) --node_type=control"
sudo su -l awx -s /bin/bash -c "awx-manage register_queue --queuename=controlplane --hostnames=$(hostname -i)"

Aggiungere i valori dei nomi di coda predefiniti nel file delle impostazioni personalizzate.

cat << EOF | sudo tee -a /etc/tower/conf.d/olam.py > /dev/null
DEFAULT_EXECUTION_QUEUE_NAME = 'execution'
DEFAULT_CONTROL_PLANE_QUEUE_NAME = 'controlplane'
EOF

Aggiorna le impostazioni del destinatario.

cat << EOF | sudo tee /etc/receptor/receptor.conf > /dev/null
---
- node:
    id: $(hostname -i)

- log-level: info

- tcp-listener:
    port: 27199

- control-service:
    service: control
    filename: /var/run/receptor/receptor.sock

- work-command:
    worktype: local
    command: /var/lib/ol-automation-manager/venv/awx/bin/ansible-runner
    params: worker
    allowruntimeparams: true
    verifysignature: false
EOF

Riavvia Oracle Linux Automation Manager

sudo systemctl restart ol-automation-manager

La conversione del nodo ibrido single-host in un nodo del piano di controllo con un database remoto è completa. Ora, aggiungeremo un nodo del piano di esecuzione per rendere questo cluster completamente funzionale.

Aggiungere un nodo del piano di esecuzione al cluster

Prima che il cluster sia completamente funzionale, aggiungere uno o più nodi di esecuzione. I nodi di esecuzione eseguono job standard utilizzando ansible-runner, che esegue playbook all'interno di un ambiente di esecuzione basato su container OLAM EE Podman.

Prepara nodo piano di esecuzione

Connettersi tramite ssh all'istanza *exe-node.
```
ssh exe-node
```
Installare il pacchetto del repository di Oracle Linux Automation Manager.
```
sudo dnf -y install oraclelinux-automation-manager-release-el8
```

Disabilitare il repository per la release precedente.

sudo dnf config-manager --disable ol8_automation ol8_automation2

Abilitare il repository della release corrente.

sudo dnf config-manager --enable ol8_automation2.2

Installare il pacchetto Oracle Linux Automation Manager.
```
sudo dnf -y install ol-automation-manager
```

Aggiungere la regola firewall Receptor.

sudo firewall-cmd --add-port=27199/tcp --permanent
sudo firewall-cmd --reload

Modificare la configurazione del socket Redis.

sudo sed -i '/^# unixsocketperm/a unixsocket /var/run/redis/redis.sock\nunixsocketperm 775' /etc/redis.conf

Copiare la chiave segreta dal nodo del piano di controllo.
```
ssh oracle@olam-node "sudo cat /etc/tower/SECRET_KEY" | sudo tee /etc/tower/SECRET_KEY > /dev/null
```
Importante: ogni nodo cluster richiede la stessa chiave segreta.

Creare un file di impostazioni personalizzato contenente le impostazioni richieste.

cat << EOF | sudo tee /etc/tower/conf.d/olamv2.py > /dev/null
CLUSTER_HOST_ID = '$(hostname -i)'
DEFAULT_EXECUTION_QUEUE_NAME = 'execution'
DEFAULT_CONTROL_PLANE_QUEUE_NAME = 'controlplane'
EOF

CLUSTER_HOST_ID è un identificativo univoco dell'host all'interno del cluster.

Creare un file di impostazioni personalizzato contenente la configurazione del database remoto.

cat << EOF | sudo tee /etc/tower/conf.d/db.py > /dev/null
DATABASES = {
    'default': {
        'ATOMIC_REQUESTS': True,
        'ENGINE': 'awx.main.db.profiled_pg',
        'NAME': 'awx',
        'USER': 'awx',
        'PASSWORD': 'password',
        'HOST': 'db-node',
        'PORT': '5432',
    }
}
EOF

Distribuire l'ambiente di esecuzione ansible-runner.
1. Aprire una shell come utente awx.
```
sudo su -l awx -s /bin/bash
```
2. Migra tutti i container esistenti alla versione podman più recente mantenendo in vita gli spazi dei nomi senza privilegi.
```
podman system migrate
```
3. Estrarre l'ambiente di esecuzione di Oracle Linux Automation Engine per Oracle Linux Automation Manager.
```
podman pull container-registry.oracle.com/oracle_linux_automation_manager/olam-ee:2.2
```
4. Uscire dalla shell awx.
```
exit
```

Generare i certificati SSL per NGINX.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/tower/tower.key -out /etc/tower/tower.crt

Immettere le informazioni richieste o semplicemente premere il tasto ENTER.

Sostituire la configurazione NGINX predefinita con la configurazione riportata di seguito.

cat << 'EOF' | sudo tee /etc/nginx/nginx.conf > /dev/null
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/doc/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include
    # for more information.
    include /etc/nginx/conf.d/*.conf;
}
EOF

Aggiornare il file di configurazione del ricevitore.

cat << EOF | sudo tee /etc/receptor/receptor.conf > /dev/null
---
- node:
    id: $(hostname -i)

- log-level: debug

- tcp-listener:
    port: 27199

- tcp-peer:
    address: $(ssh olam-node hostname -i):27199
    redial: true

- control-service:
    service: control
    filename: /var/run/receptor/receptor.sock

- work-command:
    worktype: ansible-runner
    command: /var/lib/ol-automation-manager/venv/awx/bin/ansible-runner
    params: worker
    allowruntimeparams: true
    verifysignature: false
EOF

node:id è il nome host o l'indirizzo IP del nodo corrente.
tcp-peer:address è il nome host o l'indirizzo IP e la porta della rete di ricezione sul nodo del piano di controllo.

Avviare e abilitare il servizio Oracle Linux Automation Manager.
```
sudo systemctl enable --now ol-automation-manager.service
```
Chiudere la sessione SSH connessa all'istanza exe-node, in quanto completa i passi necessari per impostare il nodo di esecuzione.
```
exit
```

Provisioning del nodo del piano di esecuzione

Confermare la connessione all'istanza olam-node controllando il prompt del terminale.

È necessario eseguire il passo di provisioning su uno dei nodi del piano di controllo del cluster e applicarlo a tutte le istanze in cluster di Oracle Linux Automation Manager.

Definire l'istanza e la coda di esecuzione.

sudo su -l awx -s /bin/bash -c "awx-manage provision_instance --hostname=$(ssh exe-node hostname -i) --node_type=execution"
sudo su -l awx -s /bin/bash -c "awx-manage register_default_execution_environments"
sudo su -l awx -s /bin/bash -c "awx-manage register_queue --queuename=execution --hostnames=$(ssh exe-node hostname -i)"

register_queue utilizza un valore queuename per creare/aggiornare e una lista di valori hostnames delimitati da virgole in cui vengono eseguiti i job.

Registra la relazione peer mesh del servizio.

sudo su -l awx -s /bin/bash -c "awx-manage register_peers $(ssh exe-node hostname -i) --peers $(hostname -i)"

Verifica della registrazione del nodo del piano di esecuzione

Connettersi tramite ssh all'istanza *exe-node.
```
ssh exe-node
```
Verificare che il servizio mesh di Oracle Linux Automation Manager sia in esecuzione.
```
sudo systemctl status receptor-awx
```

Controllare lo stato della mesh di servizio.

sudo receptorctl  --socket /var/run/receptor/receptor.sock status

Output di esempio:

[oracle@execution-node ~]$ sudo receptorctl  --socket /var/run/receptor/receptor.sock status
Node ID: 10.0.0.62
Version: +g
System CPU Count: 2
System Memory MiB: 15713

Connection   Cost
10.0.0.55   1

Known Node   Known Connections
10.0.0.55    10.0.0.62: 1
10.0.0.62    10.0.0.55: 1

Route        Via
10.0.0.55   10.0.0.55

Node         Service   Type       Last Seen             Tags
10.0.0.62   control   Stream     2022-11-06 19:46:53   {'type': 'Control Service'}
10.0.0.55   control   Stream     2022-11-06 19:46:06   {'type': 'Control Service'}

Node         Work Types
10.0.0.62   ansible-runner
10.0.0.55   local

Per ulteriori dettagli sul recettore, consulta la documentazione a monte.

Verificare le istanze cluster in esecuzione e mostrare la capacità disponibile.

sudo su -l awx -s /bin/bash -c "awx-manage list_instances"

L'output viene visualizzato green una volta che il cluster stabilisce la comunicazione tra tutte le istanze. Se i risultati vengono visualizzati con red, attendere 20-30 secondi e provare a rieseguire il comando.

Output di esempio:

[oracle@control-node ~]$ sudo su -l awx -s /bin/bash -c "awx-manage list_instances"
[controlplane capacity=136]
	10.0.0.55 capacity=136 node_type=control version=19.5.1 heartbeat="2022-11-08 16:24:03"

[default capacity=0]

[execution capacity=136]
	10.0.0.62 capacity=136 node_type=execution version=19.5.1 heartbeat="2022-11-08 17:16:45"

Ciò completa la migrazione di Oracle Linux Automation Manager a un'implementazione in cluster.

(Opzionale) Verificare che il cluster sia in funzione

Aggiornare la finestra del browser Web utilizzata per visualizzare il precedente WebUI oppure aprire una nuova finestra del browser Web e immettere l'URL.
```
https://localhost:8444
```
La porta utilizzata nell'URL deve corrispondere alla porta locale del tunnel SSH.

Nota: approvare l'avvertenza di sicurezza in base al browser utilizzato. Per Chrome, fare clic sul pulsante Avanzate, quindi sul collegamento Procedi a localhost (non sicuro).
Eseguire nuovamente il login a Oracle Linux Automation Manager con il nome utente admin e la password admin.
Dopo aver eseguito il login, viene visualizzato il file WebUI.
Utilizzando il menu di navigazione a sinistra, fare clic su Gruppi di istanze nella sezione Amministrazione.
Nella finestra principale, fare clic sul pulsante Aggiungi, quindi selezionare Aggiungi gruppo di istanze.
Immettere le informazioni necessarie nella pagina Crea nuovo gruppo di istanze.
Fare clic sul pulsante Salva.
Nella pagina di riepilogo Dettagli fare clic sulla scheda Istanze.
Nella pagina Istanze, fare clic sul pulsante Associa.
Nella pagina Seleziona istanze, fare clic sulla casella di controllo accanto al nodo di esecuzione.
Fare clic sul pulsante Salva.
Nel menu di navigazione a sinistra fare clic su Inventari nella sezione Risorse.
Nella finestra principale, fare clic sul pulsante Aggiungi, quindi selezionare Aggiungi magazzino.
Inserire le informazioni necessarie nella pagina Crea nuovo magazzino.

Per Gruppi di istanze, selezionare l'icona di ricerca per visualizzare la finestra di dialogo popup Seleziona gruppi di istanze. Fare clic sulla casella di controllo accanto al gruppo Esecuzione, quindi fare clic sul pulsante Seleziona.
Fare clic sul pulsante Salva.
Nella pagina di riepilogo Dettagli fare clic sulla scheda Host.
Nella pagina Host, fare clic sul pulsante Aggiungi.
Nella pagina Crea nuovo host immettere l'indirizzo IP o il nome host di un'istanza disponibile.

Nell'ambiente di laboratorio gratuito verrà utilizzato db-node, il nome host dell'istanza di database remoto.
Fare clic sul pulsante Salva.
Andare al menu a sinistra e fare clic su **Credenziali'.
Nella pagina Credenziali, fare clic sul pulsante Aggiungi.
Immettere le informazioni necessarie nella pagina Crea nuova credenziale.

Per il tipo di credenziale, fare clic sul menu a discesa e selezionare Computer. che visualizza le credenziali Type Details.

Immettere un nome utente di oracle e cercare la chiave privata SSH. Se si fa clic sul pulsante Browse... viene visualizzata una finestra di dialogo Open File.

Fare clic con il pulsante destro del mouse sulla finestra principale di tale finestra di dialogo, quindi selezionare Mostra file nascosti.

Quindi selezionare la cartella .ssh e il file id_rsa. Fare clic sul pulsante Open per copiare i contenuti del file di chiavi private nella finestra di dialogo SSH Private Key. Scorrere verso il basso e fare clic sul pulsante Salva.
Andare al menu a sinistra e fare clic su Inventari.
Nella pagina Scorte, fare clic sull'inventario Test.
Nella pagina di riepilogo Dettagli fare clic sulla scheda Host.
Nella pagina Host fare clic sulla casella di controllo accanto all'host db-node.

Fare quindi clic sul pulsante Esegui comando.
Nella finestra di dialogo Esegui comando, selezionare il modulo ping dall'elenco di valori Moduli e fare clic sul pulsante Successivo.
Selezionare l'ambiente di esecuzione OLAM EE (2.2) e fare clic sul pulsante Successivo.
Selezionare la credenziale del computer db-node e fare clic sul pulsante Successivo.
Il pannello aggiorna e visualizza un'anteprima del comando.

Dopo aver esaminato i dettagli, fare clic sul pulsante Avvia.
Il job verrà avviato e verrà visualizzata la pagina Output del job.

Se tutto è stato eseguito correttamente, l'output mostra un messaggio SUCCESS in cui il nodo di esecuzione ha contattato l'istanza db-node utilizzando il modulo ping di Ansible. Se l'output non viene visualizzato, aggiornare la pagina facendo clic sulla scheda Dettagli e tornando alla scheda Output.

Passi successivi

L'output all'interno di WebUI conferma la presenza di un ambiente cluster di lavoro per Oracle Linux Automation Manager. Continua a sviluppare le tue competenze e dai un'occhiata alla nostra altra formazione su Oracle Linux Automation Manager su Oracle Linux Training Station.

Documentazione su Oracle Linux Automation Manager
Formazione su Oracle Linux Automation Manager
Formazione 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

Migrate Oracle Linux Automation Manager to a Clustered Deployment

F74659-02