Note :

Ce tutoriel est disponible dans un environnement de laboratoire gratuit fourni par Oracle.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments d'Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles qui sont propres à votre environnement en nuage.

Migrer Oracle Linux Automation Manager vers un déploiement en grappe

Présentation

Qu'il s'agisse d'une mise à niveau à partir d'une version précédente ou d'une installation sur un seul hôte, les deux environnements peuvent migrer vers un déploiement en grappe. Les administrateurs doivent planifier leur topologie avant la migration, car le cluster peut être constitué d'une combinaison de noeuds de plan de contrôle, d'exécution et de saut et d'une base de données distante.

Après avoir suivi ce tutoriel, vous saurez comment migrer une installation d'hôte unique vers un déploiement en grappe avec une base de données distante.

Objectifs

Dans ce tutoriel, vous apprendrez à :

Configurer une base de données distante
Migrer vers un déploiement en grappe

Préalables

Système avec Oracle Linux Automation Manager installé.

Pour plus de détails sur l'installation d'Oracle Linux Automation Manager, voir le guide d'installation d'Oracle Linux Automation Manager.

Déployer Oracle Linux Automation Manager

Note : Si vous exécutez votre propre location, lisez les préalables du projet linux-virt-labs GitHub README.md et remplissez les conditions requises avant de déployer l'environnement de laboratoire.

Ouvrez un terminal sur le Luna Desktop.

Clonez le projet linux-virt-labs GitHub.

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

Accédez au répertoire de travail.
```
cd linux-virt-labs/olam
```

Installez les collections requises.

ansible-galaxy collection install -r requirements.yml

Mettez à jour la configuration de l'instance 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

Déployez l'environnement de l'exercice.
```
ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml" -e olam_single_host=true
```
L'environnement de laboratoire gratuit nécessite la variable supplémentaire ansible_python_interpreter car elle installe l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python. L'emplacement de l'installation de ce package est sous les modules python3.6.

La forme de déploiement par défaut utilise le processeur AMD et Oracle Linux 8. Pour utiliser une unité centrale Intel ou Oracle Linux 9, ajoutez -e instance_shape="VM.Standard3.Flex" ou -e os_version="9" à la commande de déploiement.

Important : Attendez que le livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. L'installation d'Oracle Linux Automation Manager est terminée à cette étape du livre de jeu et les instances sont prêtes. Prenez note de la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'il déploie.

Connectez-vous à WebUI

Ouvrez un terminal et configurez un tunnel SSH vers Oracle Linux Automation Manager.
```
ssh -L 8444:localhost:443 oracle@<hostname_or_ip_address>
```
Dans l'environnement de laboratoire gratuit, utilisez l'adresse IP externe de l'instance olam-node.
Ouvrez un navigateur Web et entrez l'URL.
```
https://localhost:8444
```
Note : Approuvez l'avertissement de sécurité en fonction du navigateur utilisé. Pour Chrome, cliquez sur le bouton **Avancé, puis sur le lien Passer à localhost (non sécurisé).
Connectez-vous à Oracle Linux Automation Manager avec le nom d'utilisateur de admin et le mot de passe de admin créés lors du déploiement automatisé.
Après s'être connecté, WebUI s'affiche.

Migrer vers un déploiement de grappe

Bien qu'Oracle Linux Automation Manager s'exécute en tant que déploiement d'hôte unique, il prend également en charge l'exécution en tant que grappe avec une base de données distante et des noeuds de plan de contrôle et d'exécution distincts. L'installation configure l'instance à hôte unique en tant que noeud hybrid. La première étape de la migration vers un déploiement de grappe consiste à convertir cette instance en noeud control plane.

Pour plus d'informations sur les différentes topologies d'installation, reportez-vous à la documentation du chapitre Planification de l'installation du guide d'installation d'Oracle Linux Automation Manager.

Préparer le noeud du plan de contrôle

Passez au terminal connecté à l'instance olam-node exécutant Oracle Linux Automation Manager.

Note : Désormais, nous désignerons cette instance comme noeud de plan de contrôle.
Arrêtez le service Oracle Linux Automation Manager.
```
sudo systemctl stop ol-automation-manager
```

Créez une sauvegarde de la base de données.

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

Installer la base de données distante

Copiez la sauvegarde de la base de données du noeud de plan de contrôle vers le nouvel hôte de base de données distante.
```
scp /tmp/olamv2_db_dump oracle@db-node:/tmp/
```
La commande scp communique à l'aide d'une connexion SSH entre les noeuds. Cette connexion est possible en raison de l'environnement de laboratoire gratuit configurant des connexions SSH sans mot de passe entre les instances.
Connectez-vous au moyen de ssh à l'instance db-node.
```
ssh oracle@db-node
```
Activez le flux de module de base de données.

Oracle Linux Automation Manager permet l'utilisation de la base de données Postgresql version 12 ou 13. Nous allons utiliser et activer le flux de module version 13 dans ce tutoriel.
```
sudo dnf -y module reset postgresql
sudo dnf -y module enable postgresql:13
```
Installez le serveur de base de données.
```
sudo dnf -y install postgresql-server
```

Ajoutez la règle de pare-feu de base de données.

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

Initialisez la base de données.
```
sudo postgresql-setup --initdb
```
Définissez l'algorithme de stockage par défaut de la base de données.
```
sudo sed -i "s/#password_encryption.*/password_encryption = scram-sha-256/"  /var/lib/pgsql/data/postgresql.conf
```
Pour plus de détails sur cette fonctionnalité de base de données, voir Authentification par mot de passe dans la documentation en amont.
Mettez à jour le fichier d'authentification basé sur l'hôte de la base de données.
```
echo "host  all  all 0.0.0.0/0 scram-sha-256" | sudo tee -a /var/lib/pgsql/data/pg_hba.conf > /dev/null
```
Cette ligne supplémentaire effectue l'authentification SCRAM-SHA-256 pour vérifier le mot de passe d'un utilisateur lors de la connexion à partir de n'importe quelle adresse IP.
Mettez à jour la valeur listen_address sur laquelle la base de données écoute les connexions.
```
sudo sed -i "/^#port = 5432/i listen_addresses = '"$(hostname -s)"'" /var/lib/pgsql/data/postgresql.conf
```
Vous pouvez choisir l'adresse IP ou le nom d'hôte pour cette valeur. Le tutoriel utilise hostname -s pour sélectionner le nom d'hôte.
Démarrez et activez le service de base de données.
```
sudo systemctl enable --now postgresql
```

Importez le fichier dump de la base de données.

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

Définissez le mot de passe du compte d'utilisateur de base de données Oracle Linux Automation Manager.
```
sudo su - postgres -c "psql -U postgres -d postgres -c \"alter user awx with password 'password';\""
```
Cette commande règle le mot de passe awx à password. Sélectionnez un mot de passe plus sécurisé si vous exécutez cette commande en dehors de l'environnement de laboratoire gratuit.
Fermez la session SSH connectée à l'instance de noeud de base de données, car elle effectue les étapes nécessaires pour configurer la base de données distante.
```
exit
```

Ajouter les paramètres de base de données distante

Confirmez votre connexion à l'instance olam-node en consultant l'invite de terminal.
Vérifiez que l'hôte peut communiquer avec la base de données distante.
```
pg_isready -d awx -h db-node -p 5432 -U awx
```
L'ensemble postgresql inclut la commande pg_isready. Ce package fait partie de l'installation d'origine à hôte unique. Si cette commande ne fonctionne pas, vous avez probablement ignoré une étape ci-dessus ou manqué l'accès entrant au port 5432 sur le réseau.

Ajoutez les paramètres de base de données distante à un nouveau fichier de configuration personnalisé.

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

Utilisez le même mot de passe défini précédemment pour le compte d'utilisateur de base de données awx.

Arrêtez et désactivez la base de données locale sur le noeud de plan de contrôle.
```
sudo systemctl stop postgresql
sudo systemctl disable postgresql
```
Masquer le service de base de données local.
```
sudo systemctl mask postgresql
```
Cette étape empêche le démarrage du service de base de données local lors du démarrage du service Oracle Linux Automation Manager.

Démarrez Oracle Linux Automation Manager.

sudo systemctl start ol-automation-manager

Vérifiez qu'Oracle Linux Automation Manager se connecte à la base de données distante.
```
sudo su -l awx -s /bin/bash -c "awx-manage check_db"
```
La sortie retourne les détails de la version de la base de données distante si une connexion réussit.

Supprimer l'instance de base de données locale

La suppression de la base de données locale d'origine est sécurisée après la confirmation du fonctionnement de la connexion à la base de données distante.

Supprimez les ensembles de base de données.
```
sudo dnf -y remove postgresql
```
Supprimez le répertoire pgsql contenant les anciens fichiers de données de base de données.
```
sudo rm -rf /var/lib/pgsql
```

Modifier le type de noeud du noeud de plan de contrôle

Lors de la conversion en déploiement en grappe, faites passer l'instance à hôte unique node_type de hybrid à control.

Vérifiez le type de noeud courant du noeud de plan de contrôle.
```
sudo su -l awx -s /bin/bash -c "awx-manage list_instances"
```
La sortie affiche la valeur node_type réglée à hybrid.

Supprimez le groupe d'instances par défaut.

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

Définissez la nouvelle instance et la nouvelle file d'attente.

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)"

Ajoutez les valeurs de nom de file d'attente par défaut dans le fichier des paramètres personnalisés.

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

Mettre à jour les paramètres du récepteur.

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

Redémarrer Oracle Linux Automation Manager

sudo systemctl restart ol-automation-manager

La conversion du noeud hybride à hôte unique en noeud de plan de contrôle avec une base de données distante est terminée. Maintenant, nous allons ajouter un noeud de plan d'exécution pour rendre cette grappe entièrement fonctionnelle.

Ajouter un noeud de plan d'exécution à la grappe

Avant que la grappe ne soit entièrement fonctionnelle, ajoutez un ou plusieurs noeuds d'exécution. Les noeuds d'exécution exécutent des travaux standard à l'aide d' ansible-runner, qui exécute des livres de jeu dans un environnement d'exécution basé sur un conteneur OLAM EE Podman.

Préparer le noeud du plan d'exécution

Connectez-vous au moyen de ssh à l'instance *exe-node.
```
ssh exe-node
```
Installez l'ensemble du référentiel Oracle Linux Automation Manager.
```
sudo dnf -y install oraclelinux-automation-manager-release-el8
```

Désactivez le référentiel pour l'ancienne version.

sudo dnf config-manager --disable ol8_automation ol8_automation2

Activer le référentiel de la version courante.

sudo dnf config-manager --enable ol8_automation2.2

Installez l'ensemble Oracle Linux Automation Manager.
```
sudo dnf -y install ol-automation-manager
```

Ajoutez la règle de pare-feu Receptor.

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

Modifiez la configuration du connecteur logiciel Redis.

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

Copiez la clé secrète à partir du noeud de plan de contrôle.
```
ssh oracle@olam-node "sudo cat /etc/tower/SECRET_KEY" | sudo tee /etc/tower/SECRET_KEY > /dev/null
```
Important : Chaque noeud de grappe nécessite la même clé secrète.

Créez un fichier de paramètres personnalisés contenant les paramètres requis.

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 est un identificateur unique de l'hôte dans la grappe.

Créez un fichier de paramètres personnalisés contenant la configuration de la base de données distante.

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

Déployez l'environnement d'exécution ansible-runner.
1. Ouvrez un interpréteur de commandes en tant qu'utilisateur awx.
```
sudo su -l awx -s /bin/bash
```
2. Migrez tous les conteneurs existants vers la dernière version de podman tout en conservant les espaces de noms sans privilèges actifs.
```
podman system migrate
```
3. Extrayez l'environnement d'exécution d'Oracle Linux Automation Engine pour Oracle Linux Automation Manager.
```
podman pull container-registry.oracle.com/oracle_linux_automation_manager/olam-ee:2.2
```
4. Quittez l'interpréteur de commandes de l'utilisateur awx.
```
exit
```

Générez les certificats SSL pour NGINX.

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

Entrez les informations demandées ou appuyez simplement sur la clé ENTER.

Remplacez la configuration NGINX par défaut par la configuration ci-dessous.

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

Mettez à jour le fichier de configuration Receptor.

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 est le nom d'hôte ou l'adresse IP du noeud courant.
tcp-peer:address est le nom d'hôte ou l'adresse IP et le port du maillage du récepteur sur le noeud de plan de contrôle.

Démarrez et activez le service Oracle Linux Automation Manager.
```
sudo systemctl enable --now ol-automation-manager.service
```
Fermez la session SSH connectée à l'instance exe-node, car elle effectue les étapes nécessaires pour configurer le noeud d'exécution.
```
exit
```

Provisionner le noeud du plan d'exécution

Confirmez votre connexion à l'instance olam-node en consultant l'invite de terminal.

Vous devez exécuter l'étape de provisionnement sur l'un des noeuds de plan de contrôle de la grappe et l'appliquer à toutes les instances en grappe d'Oracle Linux Automation Manager.

Définissez l'instance d'exécution et la file d'attente.

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 prend queuename pour créer/mettre à jour et une liste de hostnames délimités par des virgules où les tâches sont exécutées.

Enregistrer la relation d'appairage du maillage de services.

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

Vérifier l'enregistrement des noeuds du plan d'exécution

Connectez-vous au moyen de ssh à l'instance *exe-node.
```
ssh exe-node
```
Vérifiez que le service maillé Oracle Linux Automation Manager est en cours d'exécution.
```
sudo systemctl status receptor-awx
```

Vérifiez le statut du maillage de services.

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

Exemple de sortie :

[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

Pour plus de détails sur le récepteur, consultez la documentation en amont.

Vérifiez les instances de grappe en cours d'exécution et affichez la capacité disponible.

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

La sortie apparaît green une fois que la grappe établit la communication entre toutes les instances. Si les résultats apparaissent red, attendez 20 à 30 secondes et essayez de réexécuter la commande.

Exemple de sortie :

[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"

Cela termine la migration d'Oracle Linux Automation Manager vers un déploiement en grappe.

(Facultatif) Vérifiez que la grappe fonctionne

Actualisez la fenêtre du navigateur Web utilisée pour afficher la WebUI précédente, ou ouvrez une nouvelle fenêtre du navigateur Web et entrez l'URL.
```
https://localhost:8444
```
Le port utilisé dans l'URL doit correspondre au port local du tunnel SSH.

Note : Approuvez l'avertissement de sécurité en fonction du navigateur utilisé. Pour Chrome, cliquez sur le bouton Avancé, puis sur le lien Passer à localhost (non sécurisé).
Connectez-vous à nouveau à Oracle Linux Automation Manager avec USERNAME admin et le mot de passe admin.
Après s'être connecté, WebUI s'affiche.
Dans le menu de navigation de gauche, cliquez sur Groupes d'instances dans la section Administration.
Dans la fenêtre principale, cliquez sur le bouton Ajouter, puis sélectionnez Ajouter un groupe d'instances.
Entrez les informations requises dans la page Créer un groupe d'instances.
Cliquez sur le bouton Enregistrer.
Dans la page Sommaire Détails, cliquez sur l'onglet Instances.
Dans la page Instances, cliquez sur le bouton Associer.
Dans la page Sélectionner des instances, cochez la case à côté du noeud d'exécution.
Cliquez sur le bouton Enregistrer.
Dans le menu de navigation de gauche, cliquez sur Inventaires dans la section Ressources.
Dans la fenêtre principale, cliquez sur le bouton Ajouter, puis sélectionnez Ajouter un inventaire.
Entrez les informations requises dans la page Créer un stock.

Pour Groupes d'instances, sélectionnez l'icône de recherche pour afficher la boîte de dialogue contextuelle Sélectionner des groupes d'instances. Cochez la case à côté du groupe Exécution, puis cliquez sur le bouton Sélectionner.
Cliquez sur le bouton Enregistrer.
Dans la page Sommaire Détails, cliquez sur l'onglet Hôtes.
Dans la page Hôtes, cliquez sur le bouton Ajouter.
Dans la page Créer un hôte, entrez l'adresse IP ou le nom d'hôte d'une instance disponible.

Dans l'environnement de laboratoire gratuit, nous utiliserons db-node, qui est le nom d'hôte de l'instance de base de données distante.
Cliquez sur le bouton Enregistrer.
Naviguez jusqu'au menu à gauche, puis cliquez sur **Données d'identification".
Dans la page Données d'identification, cliquez sur le bouton Ajouter.
Entrez les informations requises dans la page Créer de nouvelles données d'identification.

Pour le type de données d'identification, cliquez sur le menu déroulant et sélectionnez Machine. Cela affiche les détails du type des données d'identification.

Entrez un nom d'utilisateur de oracle et recherchez la clé privée SSH. Cliquez sur le bouton Parcourir... pour afficher une boîte de dialogue Ouvrir un fichier.

Cliquez avec le bouton droit de la souris sur la fenêtre principale de cette boîte de dialogue, puis sélectionnez Afficher les fichiers masqués.

Sélectionnez ensuite le dossier .ssh et le fichier id_rsa. Lorsque vous cliquez sur le bouton Ouvrir, le contenu du fichier de clé privée est copié dans la boîte de dialogue Clé privée SSH. Faites défiler l'affichage vers le bas et cliquez sur le bouton Enregistrer.
Naviguez jusqu'au menu à gauche et cliquez sur Inventaires.
Dans la page Stocks, cliquez sur l'inventaire Tester.
Dans la page Sommaire Détails, cliquez sur l'onglet Hôtes.
Dans la page Hôtes, cochez la case à côté de l'hôte db-node.

Cliquez ensuite sur le bouton Exécuter la commande.
Dans la boîte de dialogue Exécuter la commande, sélectionnez le module ping dans la liste de valeurs Modules et cliquez sur le bouton Suivant.
Sélectionnez l'environnement d'exécution OLAM EE (2.2) et cliquez sur le bouton Suivant.
Sélectionnez les données d'identification de machine de noeud de base de données et cliquez sur le bouton Suivant.
Le panneau actualise et affiche un aperçu de la commande.

Après avoir vérifié les détails, cliquez sur le bouton Lancer.
La tâche lancera et affichera la page Sortie de la tâche.

Si tout a été exécuté avec succès, la sortie affiche un message SUCCESS indiquant que le noeud d'exécution a contacté l'instance db-node à l'aide du module ping d'Ansible. Si vous ne voyez pas la sortie, actualisez la page en cliquant sur l'onglet Détails et en retournant à l'onglet Sortie.

Étapes suivantes

La sortie dans WebUI confirme que vous disposez d'un environnement de grappe de travail pour Oracle Linux Automation Manager. Continuez à développer vos compétences et consultez notre autre formation Oracle Linux Automation Manager sur le poste de formation Oracle Linux.

Documentation sur Oracle Linux Automation Manager
Formation sur Oracle Linux Automation Manager
Station de formation Oracle Linux

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.

Informations sur le titre et les droits d'auteur

Migrate Oracle Linux Automation Manager to a Clustered Deployment

G32061-01