Remarques :

Ce tutoriel est disponible dans un environnement d'atelier gratuit fourni par Oracle.
Il utilise des exemples de valeurs pour les informations d'identification, la location et les compartiments Oracle Cloud Infrastructure. Lorsque vous terminez votre atelier, remplacez ces valeurs par celles propres à votre environnement cloud.

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

Introduction

Qu'il s'agisse d'une mise à niveau à partir d'une version précédente ou d'une installation à hôte unique, les deux environnements peuvent migrer vers un déploiement en cluster. 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 migrer une installation d'hôte unique vers un déploiement en cluster avec une base de données distante.

Objectifs

Dans ce tutoriel, vous allez apprendre à :

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

Prérequis

Système sur lequel Oracle Linux Automation Manager est installé.

Pour plus d'informations sur l'installation d'Oracle Linux Automation Manager, reportez-vous au Guide d'installation d'Oracle Linux Automation Manager.

Déployer Oracle Linux Automation Manager

Remarque : en cas d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et respectez les prérequis avant de déployer l'environnement d'atelier.

Ouvrez un terminal sur le bureau Luna.

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 d'exercice.
```
ansible-playbook create_instance.yml -e ansible_python_interpreter="/usr/bin/python3.6" -e "@instances.yml" -e olam_single_host=true
```
L'environnement d'atelier gratuit nécessite la variable supplémentaire ansible_python_interpreter car il installe le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python. L'emplacement d'installation de ce package se trouve sous les modules python3.6.

La forme de déploiement par défaut utilise la CPU AMD et Oracle Linux 8. Pour utiliser une CPU 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 playbook s'exécute correctement et atteignez la tâche de pause. L'installation d'Oracle Linux Automation Manager est terminée à ce stade du manuel et les instances sont prêtes. Notez la lecture précédente, qui imprime les adresses IP publiques et privées des noeuds qu'elle 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 d'exercices gratuits, utilisez l'adresse IP externe de l'instance olam-node.
Ouvrez un navigateur Web et saisissez l'URL.
```
https://localhost:8444
```
Remarque : approuvez l'avertissement de sécurité en fonction du navigateur utilisé. Pour Chrome, cliquez sur le bouton **Advanced, puis sur le lien Proceed to localhost (unsafe).
Connectez-vous à Oracle Linux Automation Manager avec le nom utilisateur admin et le mot de passe admin créés lors du déploiement automatisé.
Une fois connecté, WebUI apparaît.

Migrer vers un déploiement de cluster

Bien qu'Oracle Linux Automation Manager s'exécute en tant que déploiement à hôte unique, il prend également en charge l'exécution en tant que cluster 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 cluster consiste à convertir cette instance en noeud control plane.

For more information on different installation topologies, see the Planning the Installation chapter of the Oracle Linux Automation Manager Installation Guide documentation.

Préparer le noeud du plan de contrôle

Basculez vers le terminal connecté à l'instance olam-node exécutant Oracle Linux Automation Manager.

Remarque : à partir de maintenant, nous ferons référence à cette instance en tant que 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 base de données du noeud de plan de contrôle vers le nouvel hôte de base de données distant.
```
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 d'atelier gratuit de configuration des connexions SSH sans mot de passe entre les instances.
Connectez-vous via SSH à l'instance db-node.
```
ssh oracle@db-node
```
Activez le flux de module de base de données.

Oracle Linux Automation Manager permet d'utiliser 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 d'informations sur cette fonctionnalité de base de données, reportez-vous à 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 base de données.

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

Définissez le mot de passe du compte 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 définit le mot de passe awx sur password. Choisissez 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 db-node, au terme des étapes nécessaires à la configuration de la base de données distante.
```
exit
```

Ajout des 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
```
Le package 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 vous n'avez pas accès 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 utilisateur de base de données awx.

Arrêtez et désactivez la base de données locale sur le noeud du plan de contrôle.
```
sudo systemctl stop postgresql
sudo systemctl disable postgresql
```
Masquez le service de base de données local.
```
sudo systemctl mask postgresql
```
Cette étape empêche le service de base de données local de démarrer 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 renvoie les détails de la version de la base de données distante si une connexion est établie.

Suppression de 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 confirmation du fonctionnement de la connexion à la base de données distante.

Supprimez les packages de base de données.
```
sudo dnf -y remove postgresql
```
Enlevez 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 cluster, basculez l'instance à hôte unique node_type de hybrid vers control.

Confirmez le type de noeud actuel du noeud de plan de contrôle.
```
sudo su -l awx -s /bin/bash -c "awx-manage list_instances"
```
La sortie indique que node_type est défini sur la valeur hybrid.

Enlevez 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 de 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

Mettez à 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émarrage d'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. A présent, nous allons ajouter un noeud de plan d'exécution pour rendre ce cluster entièrement fonctionnel.

Ajouter un noeud de plan d'exécution au cluster

Avant que le cluster ne soit entièrement fonctionnel, ajoutez des 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 jeux dans un environnement d'exécution basé sur un conteneur OLAM EE Podman.

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

Connectez-vous via SSH à l'instance *exe-node.
```
ssh exe-node
```
Installez le package de 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

Activez le référentiel de la version actuelle.

sudo dnf config-manager --enable ol8_automation2.2

Installez le package Oracle Linux Automation Manager.
```
sudo dnf -y install ol-automation-manager
```

Ajoutez la règle de pare-feu du récepteur.

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

Modifiez la configuration du socket 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 du 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 cluster requiert la même clé secrète.

Créez un fichier de paramètres personnalisé 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 le cluster.

Créez un fichier de paramètres personnalisé contenant la configuration de 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 shell en tant qu'utilisateur awx.
```
sudo su -l awx -s /bin/bash
```
2. Migrez les conteneurs existants vers la dernière version de podman tout en conservant les espaces de noms sans privilège.
```
podman system migrate
```
3. Extrayez l'environnement d'exécution 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 le shell 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 touche 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 du récepteur.

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 en cours.
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, en suivant les étapes nécessaires pour configurer le noeud d'exécution.
```
exit
```

Provisionner le noeud de 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 du cluster et l'appliquer à toutes les instances en cluster 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 utilise une valeur queuename pour créer/mettre à jour et la liste des valeurs hostnames séparées par des virgules où les travaux sont exécutés.

Enregistrez la relation de pair 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'inscription du noeud du plan d'exécution

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

Vérifiez le statut du maillage de service.

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, reportez-vous à la documentation en amont.

Vérifiez les instances de cluster 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 le cluster a établi 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"

Cette opération termine la migration d'Oracle Linux Automation Manager vers un déploiement en cluster.

(Facultatif) Vérifiez que le cluster fonctionne

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

Remarque : 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 le nom utilisateur admin et le mot de passe admin.
Une fois connecté, WebUI apparaît.
Dans le menu de navigation de gauche, cliquez sur Groupes d'instances sous 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 sur la page Créer un groupe d'instances.
Cliquez sur le bouton Enregistrer.
Sur la page de récapitulatif Détails, cliquez sur l'onglet Instances.
Sur la page Instances, cliquez sur le bouton Associer.
Sur la page Sélectionner des instances, cochez la case en regard du noeud d'exécution.
Cliquez sur le bouton Enregistrer.
Dans le menu de navigation de gauche, cliquez sur Stocks sous la section Ressources.
Dans la fenêtre principale, cliquez sur le bouton Ajouter, puis sélectionnez Ajouter un inventaire.
Entrez les informations requises sur la page Créer un stock.

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

Dans l'environnement d'atelier gratuit, nous allons utiliser db-node, qui est le nom d'hôte de l'instance de base de données distante.
Cliquez sur le bouton Enregistrer.
Accédez au menu de gauche et cliquez sur **Informations d'identification'.
Sur la page Informations d'identification, cliquez sur le bouton Ajouter.
Entrez les informations requises sur la page Créer des informations d'identification.

Pour le type d'informations d'identification, cliquez sur le menu déroulant et sélectionnez Ordinateur. Affiche les informations d'identification Détails du type.

Entrez le nom utilisateur oracle et recherchez la clé privée SSH. Cliquez sur le bouton Parcourir... pour afficher une boîte de dialogue Ouvrir le 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és privées est copié dans la boîte de dialogue Clé privée SSH. Faites défiler l'écran vers le bas et cliquez sur le bouton Enregistrer.
Accédez au menu de gauche et cliquez sur Stocks.
Sur la page Stocks, cliquez sur l'inventaire Tester.
Sur la page de récapitulatif Détails, cliquez sur l'onglet Hôtes.
Sur la page Hôtes, cochez la case en regard de l'hôte db-node.

Cliquez ensuite sur le bouton Run Command.
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 Next.
Sélectionnez les informations d'identification de machine db-node et cliquez sur le bouton Next.
Le panneau est actualisé et affiche un aperçu de la commande.

Après avoir vérifié les détails, cliquez sur le bouton Lancer.
Le travail lance et affiche la page Sortie du travail.

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

Etapes suivantes

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

Documentation d'Oracle Linux Automation Manager
Formation Oracle Linux Automation Manager
Station de formation Oracle Linux

Ressources de formation supplémentaires

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

Pour obtenir la documentation produit, consultez le site Oracle Help Center.

Informations relatives au titre et au copyright

Migrate Oracle Linux Automation Manager to a Clustered Deployment

F74656-02