Remarques :

Créer une pile LAMP à plusieurs machines virtuelles sur Oracle Virtualization

Introduction

L'hôte Oracle Linux KVM est au cœur de la solution de virtualisation Oracle. En plus de cet hyperviseur, vous pouvez exécuter de nombreuses machines virtuelles, chacune exécutant l'un des systèmes d'exploitation pris en charge, notamment Oracle Linux, RHEL, Windows, Ubuntu, Solaris et d'autres. Cette solution de virtualisation est gérée via Oracle Linux Virtualization Manager qui offre une interface unique pour organiser les choses. En plus de la gestion multi-hôte/multi-VM, Oracle Linux Virtualization Manager permet des fonctionnalités clés de la solution Oracle Virtualization. Par exemple, Oracle Linux Virtualization Manager fournit une haute disponibilité automatique avec le basculement de machine virtuelle, la migration en direct des machines virtuelles entre les hôtes sans temps d'arrêt, le contrôle d'accès basé sur les rôles et la journalisation d'audit, ainsi que des workflows de sauvegarde et de récupération après sinistre simplifiés. Ces fonctionnalités d'entreprise transforment Oracle Linux KVM d'hôtes individuels en une véritable plate-forme de virtualisation d'entreprise.

Dans ce tutoriel, nous allons explorer la technologie de base des hyperviseurs qui optimise Oracle Virtualization. La machine virtuelle basée sur le noyau (KVM) est un hyperviseur open source de type 1 (métal nu). Cette fonctionnalité permet à un système hôte, tel qu'Oracle Linux, d'héberger plusieurs machines virtuelles ou invités lorsqu'il est exécuté sur du matériel pris en charge.

Ce tutoriel va déployer Oracle Linux KVM pour créer des machines virtuelles configurées avec des applications de pile LAMP, ce qui vous permettra d'héberger des environnements de développement Web complets avec des composants Linux, Apache, MySQL et PHP sur plusieurs machines virtuelles.

Important : Les deux codes d'application de cet exercice sont destinés à des fins pédagogiques uniquement. Ils sont conçus pour aider les développeurs à acquérir et à mettre en pratique des compétences de développement d'applications avec la pile LAMP. Ces codes ne sont pas destinés aux environnements de production et ne doivent pas être utilisés tels quels dans un environnement actif.

Objectifs

Prérequis

Tout système Oracle Linux avec les configurations suivantes :

Etape 1 : déploiement d'Oracle Linux

Remarque : si vous êtes en cours d'exécution dans votre propre location, lisez le projet linux-virt-labs GitHub README.md et complétez les prérequis avant de déployer l'environnement d'exercice.

  1. Ouvrez un terminal à partir du bureau Luna.

  2. Clonez le projet linux-virt-labs GitHub.

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

  3. Accédez au répertoire de travail.

    cd linux-virt-labs/ol

  4. Installez les ensembles requis.

    ansible-galaxy collection install -r requirements.yml

  5. Déployez l'environnement d'exercice.

    ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e instance_ocpus="4" -e instance_memory="64"

    L'environnement d'exercice libre requiert la variable supplémentaire local_python_interpreter, qui définit ansible_python_interpreter pour les lectures exécutées sur localhost. Cette variable est nécessaire car l'environnement installe le package RPM pour le kit SDK Oracle Cloud Infrastructure pour Python, situé sous les modules python3.6.

    La forme de déploiement par défaut utilise l'UC AMD et Oracle Linux 8. Pour utiliser une CPU Intel, ajoutez -e instance_shape="VM.Standard3.Flex"

    Important : attendez que le guide de lecture s'exécute correctement et atteignez la tâche de pause. A ce stade du manuel, l'installation d'Oracle Linux est terminée et les instances sont prêtes. Prenez note de la lecture précédente, qui affiche les adresses IP publiques et privées des noeuds qu'elle déploie et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Etape 2 : validation de l'environnement prenant en charge la virtualisation

  1. Ouvrez un nouveau terminal à partir du bureau Luna et connectez-vous via SSH à l'instance ol-node-01.

    ssh opc@<YOUR ol-node-01 PUBLIC_IP>

  2. Exécutez la commande suivante pour déterminer votre type d'UC.

    grep -e 'vendor_id' /proc/cpuinfo | uniq

    vendor_id indique AuthenticAMD pour une CPU AMD ou GenuinIntel pour une CPU Intel.

  3. Vérifiez si le matériel prend en charge la virtualisation.

    Exécutez la commande correspondant à votre type d'UC.

    1. Vérifiez que les extensions de CPU AMD V existent.
    grep -w -o 'svm' /proc/cpuinfo | uniq
    1. Vérifiez que les extensions de CPU Intel VT existent.
    grep -w -o 'vmx' /proc/cpuinfo | uniq

    L'existence de l'un de ces indicateurs dans la sortie de commande indique que ce système prend en charge la virtualisation. Vous pouvez également utiliser la commande lscpu et rechercher l'entrée Virtualization dans la sortie.

  4. Recherchez les modules KVM chargés.

    lsmod | grep kvm

    La sortie affiche les modules de noyau KVM après l'installation des packages de virtualisation et le démarrage du service libvirtd. Sur les systèmes cloud tels qu'OCI, ces modules se chargent automatiquement au démarrage de libvirtd, et non lors de l'installation du package. La séquence de chargement est : install packages → start libvirtd service → modules apparaissent dans la sortie lsmod.

Etape 3 : Installer et démarrer KVM

  1. Vérifiez la version d'exécution d'Oracle Linux.

    hostnamectl | grep 'Operating System'

  2. Installez les packages logiciels associés pour la virtualisation Oracle Linux.

    Ces commandes installent les packages de virtualisation, qui incluent libvirt, et d'autres dépendances sur Oracle Linux. Le package libvirt fournit une bibliothèque de logiciels et une API pour gérer les machines virtuelles KVM et inclut le démon libvirtd qui s'exécute en arrière-plan pour gérer la gestion réelle des machines virtuelles.

    sudo dnf module install -y virt

  3. Installez virt-install - outil de création et de configuration de machines virtuelles à l'aide de l'hyperviseur KVM (machine virtuelle basée sur le noyau).

    sudo dnf install -y virt-install

  4. Vérifiez que la machine hôte est prête et configurée pour exécuter les machines virtuelles libvirt.

    virt-host-validate

    Si toutes les vérifications réussissent, le système est préparé pour la création de machines virtuelles. Si des vérifications échouent, suivez les instructions pour corriger le problème. Si une vérification renvoie la valeur de WARN, envisagez de suivre les instructions pour améliorer les capacités de virtualisation.

  5. Démarrez les services Systemd, en leur permettant de démarrer automatiquement à chaque initialisation.

    sudo systemctl enable --now libvirtd.service

  6. Vérifiez le statut des services pour vérifier qu'ils sont en fonctionnement.

    sudo systemctl status libvirtd.service

    La sortie affiche le service comme étant activé et en cours d'exécution. Si nécessaire, entrez la lettre 'q' pour quitter le mode de sortie

Etape 4 : création de deux machines virtuelles à l'aide d'images Oracle Cloud

  1. Accédez à l'emplacement de stockage de l'image KVM.

    cd /var/lib/libvirt/images

  2. Téléchargez le modèle de machine virtuelle Oracle Linux.

    sudo curl -O https://yum.oracle.com/templates/OracleLinux/OL8/u10/x86_64/OL8U10_x86_64-kvm-b237.qcow2

    Créer une base de données de machine virtuelle 01

  3. Créez un fichier de métadonnées.

    cat << 'EOF' | sudo tee ~/meta-data > /dev/null
instance-id: iid-local01
local-hostname: vm-01
EOF

  4. Créez un fichier de données utilisateur.

    cat << 'EOF' | sudo tee ~/user-data > /dev/null
#cloud-config

system_info:
  default_user:
    name: opc

ssh_authorized_keys:
  - <paste_public_key_here>
EOF

  5. Générer une paire de clés SSH pour une connexion sécurisée à la machine virtuelle

    ssh-keygen -t rsa -b 4096

    Appuyez sur Enter pour accepter chacune des valeurs par défaut. La commande écrit la paire de clés dans le répertoire .ssh du répertoire de base de l'utilisateur.

  6. Extraire la clé SSH publique générée 
    SSHKEY=$(cat ~/.ssh/id_rsa.pub)
  7. Mettre à jour le fichier de données utilisateur avec la clé SSH publique générée 
    sed -i "s|<paste_public_key_here>|${SSHKEY}|g" ~/user-data
  8. Générer une image ISO contenant les fichiers de données utilisateur et de métadonnées 
    sudo genisoimage -output /var/lib/libvirt/images/vm-01.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
  9. Rechercher la variante du système d'exploitation correspondant à l'image téléchargée 
    osinfo-query os | grep ol8
  10. Copier l'image Oracle Linux vers une nouvelle image disque pour vm-01 
    sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-01.qcow
  11. Créer une machine virtuelle nommée vm-01 avec les ressources et la configuration spécifiées 
    sudo virt-install --name vm-01 \
--memory 2048 \
--vcpus 2 \
--disk /var/lib/libvirt/images/vm-01.qcow,device=disk,bus=virtio \
--disk /var/lib/libvirt/images/vm-01.iso,device=cdrom \
--os-type linux --os-variant ol8.10 \
--virt-type kvm --graphics none \
--network network=default,model=virtio \
--noautoconsole \
--import
  12. Répertorier toutes les machines virtuelles en cours d'exécution 
    sudo virsh list

  13. Récupérez l'adresse IP de la machine virtuelle vm-01.

    sudo virsh net-dhcp-leases --network default

  14. Vérifiez que la machine virtuelle fonctionne en vous connectant à ssh.

    ssh opc@<ip_address_of_vm-01>

  15. Obtenez des détails sur la machine virtuelle en exécutant hostnamectl.

    hostnamectl

  16. Quitter le serveur vm-01 pour passer à l'étape suivante

    exit

    Vous pouvez vérifier la version et obtenir des détails supplémentaires sur le système d'exploitation au sein de la machine virtuelle en exécutant hostnamectl.

    Créer VM-02 (serveur Web)

  17. Créer un fichier de métadonnées pour vm-02

    cat << 'EOF' | sudo tee ~/meta-data > /dev/null
instance-id: iid-local02
local-hostname: vm-02
EOF
  18. Générer une image ISO pour vm-02 
    sudo genisoimage -output /var/lib/libvirt/images/vm-02.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
  19. Copier l'image Oracle Linux vers une nouvelle image de disque pour vm-02 
    sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-02.qcow
  20. Créer une machine virtuelle nommée vm-02 avec les ressources et la configuration spécifiées 
    sudo virt-install --name vm-02 \
--memory 2048 \
--vcpus 2 \
--disk /var/lib/libvirt/images/vm-02.qcow,device=disk,bus=virtio \
--disk /var/lib/libvirt/images/vm-02.iso,device=cdrom \
--os-type linux --os-variant ol8.10 \
--virt-type kvm --graphics none \
--network network=default,model=virtio \
--noautoconsole \
--import
  21. Répertorier toutes les machines virtuelles en cours d'exécution 
    sudo virsh list

  22. Récupérez l'adresse IP de la machine virtuelle vm-02.

    sudo virsh net-dhcp-leases --network default

  23. Vérifiez que la machine virtuelle fonctionne en vous connectant à ssh.

    ssh opc@<ip_address_of_vm-02>

  24. Obtenez des détails sur la machine virtuelle en exécutant hostnamectl.

    hostnamectl

  25. Quitter le serveur vm-02 pour passer à l'étape suivante

    exit

  26. Vous pouvez vérifier la version et obtenir des détails supplémentaires sur le système d'exploitation au sein de la machine virtuelle en exécutant hostnamectl.

    hostnamectl

    Exemple de résultat :

    [oracle@ol-node01 images]$ ssh opc@192.168.122.46
The authenticity of host '192.168.122.46 (192.168.122.46)' can't be established.
ECDSA key fingerprint is SHA256:xcuVfQdoFDCC72i7plD0OfqDTSBG6QWhOm5ti4HIKEs.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '192.168.122.46' (ECDSA) to the list of known hosts.

[opc@vm-01 ~]$ hostnamectl
   Static hostname: vm-01
         Icon name: computer-vm
           Chassis: vm
        Machine ID: 30c9345b511448b681aafb3371de9792
           Boot ID: c2d5586b094f4d299a4ba6c05086d004
    Virtualization: kvm
  Operating System: Oracle Linux Server 8.10
       CPE OS Name: cpe:/o:oracle:linux:8:10:server
            Kernel: Linux 5.15.0-206.153.7.1.el8uek.x86_64
      Architecture: x86-64
  27. Extrayez l'adresse IP de vm-01 et enregistrez-la dans la variable VM01_IP 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  28. Extrayez l'adresse IP de vm-02 et enregistrez-la dans la variable VM02_IP 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  29. Assurez-vous que l'adresse IP des machines virtuelles est correctement enregistrée : 
     echo "VM-01 (Web): $VM01_IP"

     echo "VM-02 (Web): $VM02_IP"
  30. Test de la commande SSH pour les machines virtuelles 
     ssh -o ConnectTimeout=10 opc@$VM01_IP "echo 'VM-01 OK'"

     ssh -o ConnectTimeout=10 opc@$VM02_IP "echo 'VM-02 OK'"

Etape 5 : configuration de MySQL sur VM-01

Installer MySQL

  1. A partir de l'instance ol-node-01, SSH établit une connexion SSH à VM-01 
     ssh opc@$VM01_IP
  2. Télécharger la configuration du référentiel MySQL 
     sudo yum -y install https://dev.mysql.com/get/mysql84-community-release-el8-1.noarch.rpm
  3. Désactiver le module MySQL par défaut pour éviter les conflits 
     sudo yum -y module disable mysql
  4. Installer le serveur et le client MySQL 
     sudo yum install -y mysql mysql-server
  5. Démarrer le service MySQL 
     sudo systemctl start mysqld
  6. Activer le démarrage du service MySQL à l'initialisation 
     sudo systemctl enable mysqld
  7. Autoriser le trafic MySQL entrant via le pare-feu 
     sudo firewall-cmd --permanent --add-service=mysql
  8. Recharger la configuration du pare-feu pour appliquer les modifications 
     sudo firewall-cmd --reload

    Configurer MySQL

  9. Extraire le mot de passe root temporaire du journal MySQL 
     TEMP_PASS=$(sudo grep 'temporary password' /var/log/mysqld.log | awk '{print $NF}')
  10. Connectez-vous à MySQL avec le mot de passe root temporaire 
     mysql -uroot -p$TEMP_PASS --connect-expired-password
  11. Remplacer le mot de passe root par une valeur sécurisée 
     ALTER USER 'root'@'localhost' IDENTIFIED BY 'Welcome#123';
  12. Créer un utilisateur 'admin' avec un mot de passe sécurisé 
     CREATE USER 'admin'@'%' IDENTIFIED BY 'Welcome#123';
  13. Accorder tous les privilèges à l'utilisateur 'admin' 
     GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;
  14. Créer un utilisateur 'empuser' avec un mot de passe sécurisé 
     CREATE USER 'empuser'@'%' IDENTIFIED BY 'Welcome#123';
  15. Accorder tous les privilèges à 'empuser' 
     GRANT ALL PRIVILEGES ON *.* TO 'empuser'@'%' WITH GRANT OPTION;
  16. Recharger les tables de privilèges pour appliquer les modifications 
     FLUSH PRIVILEGES;
  17. Quitter le shell MySQL 
     \q
  18. Quitter la session SSH à partir de VM-01 
     exit

Etape 6 : Configurer Apache/PHP sur VM-02

  1. A partir de l'instance ol-node-01, SSH établit une connexion SSH à VM-02 
     ssh opc@$VM02_IP
  2. Installation du serveur Apache HTTP 
     sudo yum install -y httpd
  3. Installer PHP 8.2 et ses dépendances 
     sudo dnf install -y @php:8.2
  4. Installer des extensions PHP MySQL et JSON 
     sudo yum install -y php-mysqlnd php-json
  5. Activer et démarrer le serveur Apache HTTP 
     sudo systemctl enable --now httpd
  6. Autoriser le trafic HTTP entrant sur le port 80 
     sudo firewall-cmd --permanent --add-port=80/tcp
  7. Recharger la configuration du pare-feu pour appliquer les modifications 
     sudo firewall-cmd --reload
  8. Autoriser Apache à se connecter aux ressources réseau 
     sudo setsebool -P httpd_can_network_connect 1
  9. Quitter la session SSH à partir de VM-02 
     exit

Etape 7 : test d'Apache

  1. Affichez l'adresse IP de VOS adresses IP VM_02 VM-02 : 
     echo "VM-02 (Web): $VM02_IP"

  2. Ouvrir un nouveau terminal à partir du bureau Luna et créer un tunnel SSH pour accéder au serveur Web VM-02 à partir de la machine locale

    … assurez-vous d'abord de remplacer **** et ****

     ssh -L 8081:<YOUR VM_02 IP>:80 opc@<YOUR ol-node-01 PUBLIC_IP>
  3. Utiliser un navigateur de Luna ou un environnement sur site pour tester Apache en accédant au serveur Web via le tunnel SSH 
     http://localhost:8081

    Important : laissez le tunnel SSH et le navigateur ouverts pour une utilisation ultérieure

Etape 8 : création d'une application de test

  1. Revenir à l'instance SSH opc@ol-node-01

  2. Récupérer l'adresse IP de VM-01 à partir de baux DHCP 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Récupérer l'adresse IP de VM-02 à partir de baux DHCP 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. A partir de l'instance ol-node-01, SSH établit une connexion SSH à VM-02 
     ssh opc@$VM02_IP
  5. Créer une page d'informations PHP pour afficher la configuration PHP 
     sudo tee /var/www/html/info.php > /dev/null << 'EOF'
 <?php phpinfo(); ?>
 EOF

  6. Créer une application de test de connexion à la base de données

     sudo tee /var/www/html/dbtest.php > /dev/null << 'EOF'
 <?php
 echo "<h1>Multi-VM LAMP Stack Test</h1>";

 // Database connection details
 define('DB_SERVER', '$VM01_IP');
 define('DB_USERNAME', 'admin');
 define('DB_PASSWORD', 'Welcome#123');
 define('DB_NAME', 'mysql');

 echo "<p>Testing connection to MySQL at: " . DB_SERVER . "</p>";

 // Test network connectivity
 $fp = @fsockopen(DB_SERVER, 3306, $errno, $errstr, 5);
 if (!$fp) {
     echo "<p style='color: red;'>ERROR: Cannot reach MySQL server</p>";
     echo "<p>Error: $errstr ($errno)</p>";
 } else {
     echo "<p style='color: green;'>✓ Network connection successful</p>";
     fclose($fp);
        
     // Test MySQL connection
     $link = mysqli_connect(DB_SERVER, DB_USERNAME, DB_PASSWORD, DB_NAME);
     if($link === false){
         echo "<p style='color: red;'>ERROR: Could not connect to MySQL</p>";
         echo "<p>Error: " . mysqli_connect_error() . "</p>";
     } else {
         echo "<p style='color: green;'>✓ Successfully Connected to MySQL!</p>";
         echo "<p>MySQL Version: " . mysqli_get_server_info($link) . "</p>";
         echo "<p>Host Info: " . mysqli_get_host_info($link) . "</p>";
         mysqli_close($link);
     }
 }
 ?>
 EOF
  7. Définir les autorisations du fichier d'application 
     sudo chown apache:apache /var/www/html/*.php
  8. Mettez à jour la ligne define('DB_SERVER', '$VM01_IP') ; en modifiant la valeur $VM01_IP avec la valeur d'adresse IP vm-01 enregistrée. 
     sudo vi /var/www/html/dbtest.php

    Exemple de résultat :

    ```texte … Codez avant define('DB_SERVER', '$VM01_IP') ; … Codez après define('DB_SERVER', '192.168.122. ? ? ?') ;

  9. Quitter VM-02

     exit

Etape 9 : Accès à votre serveur Web et à votre application de test de base de données

  1. Si le tunnel SSH est fermé, créez pour le test de base 
     ssh -L 8081:$VM02_IP:80 opc@<YOUR ol-node-01 PUBLIC_IP>
  2. Test LAMP de base Naviguez jusqu'à : 
     http://localhost:8081/info.php
  3. Test de base de données Démonstration Parcourir vers : 
    http://localhost:8081/dbtest.php

Résultats attendus:

Etape 10 : création et chargement de la base de données des employés

  1. Vous devez être dans votre instance ssh opc@ol-node-01

  2. Récupérer l'adresse IP de VM-01 à partir de baux DHCP 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Récupérer l'adresse IP de VM-02 à partir de baux DHCP 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. A partir de l'instance SSH opc@ol-node-01, établissez une connexion SSH à VM-01 
     ssh opc@$VM01_IP
  5. Changer en dossier /tmp 
     cd /tmp
  6. Télécharger la base de données d'exemple d'employé MySQL 
     sudo curl -L -o employees_db_full.zip "https://objectstorage.us-ashburn-1.oraclecloud.com/p/5UYZYk1vh241OqeHp_J0xnzBpzUOxZtTgaqCH16OP7HpOjC71W207gAY9EY1rW2U/n/idazzjlcjqzj/b/mysql-ee-downloads/o/employees_db_full.zip"
  7. Installer les outils de compression 
     sudo dnf install -y unzip
  8. Extraire la base de données 
     sudo unzip employees_db_full.zip

     cd employees_db_full
  9. charger la base de données, 
     mysql -u admin -pWelcome#123 < employee.sql
  10. Vérifier le chargement de la base de données 
     mysql -u admin -pWelcome#123 -e "USE employee; SHOW TABLES; SELECT COUNT(*) FROM employee;"
  11. Quitter la machine virtuelle de base de données 
     exit

Etape 11 : Créer une application Web de base de données des employés

  1. A partir de l'instance ol-node-01, SSH établit une connexion SSH à VM-02 
     ssh opc@$VM02_IP
  2. Créer une application de base de données pour les employés professionnels 
     sudo tee /var/www/html/employee.php > /dev/null << 'EOF'
 <!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Employee Database - Multi-VM LAMP Demo</title>
     <style>
         body { 
             font-family: Arial, sans-serif; 
             max-width: 1200px; 
             margin: 0 auto; 
             padding: 20px;
             background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
         }
         .header { 
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             color: white; 
             text-align: center; 
             padding: 30px;
             border-radius: 15px;
             margin-bottom: 20px;
             box-shadow: 0 8px 16px rgba(0,0,0,0.1);
         }
         .info-box { 
             background: rgba(255,255,255,0.9);
             padding: 25px; 
             border-radius: 12px;
             box-shadow: 0 4px 8px rgba(0,0,0,0.1);
             margin-bottom: 20px;
             backdrop-filter: blur(10px);
         }
         .success { color: #28a745; font-weight: bold; }
         .error { color: #dc3545; font-weight: bold; }
         table { 
             width: 100%; 
             border-collapse: collapse; 
             margin: 20px 0;
             background: rgba(255,255,255,0.9);
             border-radius: 12px;
             overflow: hidden;
             box-shadow: 0 4px 8px rgba(0,0,0,0.1);
         }
         th, td { 
             padding: 15px; 
             text-align: left; 
             border-bottom: 1px solid #ddd;
         }
         th { 
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             color: white;
             font-weight: bold;
         }
         tr:hover { background-color: rgba(102, 126, 234, 0.1); }
         .stats { 
             display: grid; 
             grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); 
             gap: 20px; 
             margin: 20px 0; 
         }
         .stat-card { 
             background: white; 
             padding: 20px; 
             border-radius: 10px; 
             text-align: center; 
             box-shadow: 0 4px 8px rgba(0,0,0,0.1);
         }
         .stat-number { font-size: 2em; font-weight: bold; color: #667eea; }
     </style>
 </head>
 <body>
     <div class="header">
         <h1>🏢 Employee Database Demo</h1>
         <p>MySQL Employee Sample Database on Multi-VM Architecture</p>
     </div>

     <?php
     // Database connection details
     define('DB_SERVER', '$VM01_IP');
     define('DB_USERNAME', 'empuser');
     define('DB_PASSWORD', 'Welcome#123');
     define('DB_NAME', 'employee');

     try {
         // Connect to MySQL database on separate VM
         $pdo = new PDO("mysql:host=" . DB_SERVER . ";dbname=" . DB_NAME, DB_USERNAME, DB_PASSWORD);
         $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            
         echo '<div class="info-box success">';
         echo '<h2>✅ Connected to Employee Database</h2>';
         echo '<p><strong>Database Server:</strong> ' . DB_SERVER . ' (vm-01)</p>';
         echo '<p><strong>Web Server:</strong> ' . gethostname() . ' (vm-02)</p>';
         echo '</div>';
            
         // Get database statistics
         $stats = [];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM employee");
         $stats['employee'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM department");
         $stats['departments'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM salary");
         $stats['salaries'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM title");
         $stats['titles'] = $stmt->fetch()['count'];
            
         echo '<div class="info-box">';
         echo '<h2>📊 Database Statistics</h2>';
         echo '<div class="stats">';
         echo '<div class="stat-card"><div class="stat-number">' . number_format($stats['employee']) . '</div><div>Employee</div></div>';
         echo '<div class="stat-card"><div class="stat-number">' . number_format($stats['departments']) . '</div><div>Departments</div></div>';
         echo '<div class="stat-card"><div class="stat-number">' . number_format($stats['salaries']) . '</div><div>Salary Records</div></div>';
         echo '<div class="stat-card"><div class="stat-number">' . number_format($stats['titles']) . '</div><div>Job Titles</div></div>';
         echo '</div>';
         echo '</div>';
            
         // Show recent employee
         echo '<div class="info-box">';
         echo '<h2>👥 Sample Employee Data</h2>';
         $stmt = $pdo->query("SELECT emp_no, first_name, last_name, gender, hire_date FROM employee ORDER BY hire_date DESC LIMIT 20");
         $employee = $stmt->fetchAll();
            
         echo '<table>';
         echo '<thead><tr><th>Employee #</th><th>First Name</th><th>Last Name</th><th>Gender</th><th>Hire Date</th></tr></thead>';
         echo '<tbody>';
            
         foreach ($employee as $emp) {
             echo '<tr>';
             echo '<td>' . htmlspecialchars($emp['emp_no']) . '</td>';
             echo '<td>' . htmlspecialchars($emp['first_name']) . '</td>';
             echo '<td>' . htmlspecialchars($emp['last_name']) . '</td>';
             echo '<td>' . htmlspecialchars($emp['gender']) . '</td>';
             echo '<td>' . htmlspecialchars($emp['hire_date']) . '</td>';
             echo '</tr>';
         }
         echo '</tbody></table>';
         echo '</div>';
            
         // Show departments
         echo '<div class="info-box">';
         echo '<h2>🏬 Departments</h2>';
         $stmt = $pdo->query("SELECT dept_no, dept_name FROM department ORDER BY dept_name");
         $departments = $stmt->fetchAll();
            
         echo '<table>';
         echo '<thead><tr><th>Department Code</th><th>Department Name</th></tr></thead>';
         echo '<tbody>';
            
         foreach ($departments as $dept) {
             echo '<tr>';
             echo '<td>' . htmlspecialchars($dept['dept_no']) . '</td>';
             echo '<td>' . htmlspecialchars($dept['dept_name']) . '</td>';
             echo '</tr>';
         }
         echo '</tbody></table>';
         echo '</div>';
            
     } catch (PDOException $e) {
         echo '<div class="info-box error">';
         echo '<h2>❌ Database Connection Error</h2>';
         echo '<p>Error: ' . htmlspecialchars($e->getMessage()) . '</p>';
         echo '</div>';
     }
     ?>

     <div class="info-box">
         <h2>🏗️ Multi-VM Architecture</h2>
         <p><strong>Database VM (vm-01):</strong> MySQL Server with Employee Database</p>
         <p><strong>Web VM (vm-02):</strong> Apache + PHP Web Application</p>
         <p><strong>Data Source:</strong> MySQL Sample Employee Database</p>
         <p><strong>Records:</strong> 300,000+ employee, 400,000+ salary records</p>
     </div>
 </body>
 </html>
 EOF
  3. Définir les droits d'accès appropriés 
     sudo chown apache:apache /var/www/html/employee.php
  4. Mettez à jour la ligne define('DB_SERVER', '$VM01_IP') ; en modifiant la valeur $VM01_IP avec la valeur d'adresse IP enregistrée 
     sudo vi /var/www/html/employee.php

    Exemple de résultat :

    ```texte … Codez avant define('DB_SERVER', '$VM01_IP') ; … Codez après define('DB_SERVER', '192.168.122. ? ? ?') ;

  5. Quitter la machine virtuelle du serveur Web 
     exit

Etape 12 : Accès à l'application Employee

  1. Si le tunnel SSH est fermé, créez pour le test de base 
     ssh -L 8081:$VM02_IP:80 opc@<YOUR ol-node-01 PUBLIC_IP>
  2. Démonstration de la base de données des employés Parcourir vers : 
     http://localhost:8081/employee.php

Résultats attendus:

Applications disponibles :

🔧 Test LAMP de base (http://localhost:8081/dbtest.php)

🏢 Démonstration d'Employee Database (http://localhost:8081/employee.php)

Commandes de gestion essentielles

Gestion des machines virtuelles

  1. Répertorier les machines virtuelles en cours d'exécution et leur statut 
     sudo virsh list
  2. Démarrer VM-01 
     sudo virsh start vm-01
  3. Arrêter VM-01 
     sudo virsh shutdown vm-01
  4. Affichage des baux DHCP pour les machines virtuelles sur le réseau par défaut 
     sudo virsh net-dhcp-leases --network default

Configuration Pour l'exécution de cet atelier sur Oracle Cloud Infrastructure

  1. Configuration du réseau cloud virtuel `` Naviguer : Mise en réseau → Réseaux cloud virtuels → Lancer l'assistant VCN
    • Nom : ol-vcn-01
    • Créez VCN Navigate : Networking → Virtual Cloud Networks → kvm-network → Security Lists Ajoutez les règles entrantes suivantes :
    • SSH : source 0.0.0.0/0, port TCP 22
    • HTTP : source 0.0.0.0/0, port TCP 80 ```
  2. Configuration de l'instance de calcul : 
         Navigation: Hamburger Menu → Compute → Instances → Create Instance

     Configuration:
     - Name: ol-node-01
     - Image: Oracle Linux 8 (Latest)
     - Shape: VM.Standard.E4.Flex (4 OCPUs, 16GB RAM)
     - Boot Volume: 100 GB
     - VCN: ol-vcn-01 
     - Subnet: Public subnet ol-vcn-01
     - Assign Public IP: Yes
     - Add SSH Key: Upload your public key
  3. Tester l'adresse IP publique Compute avec SSH 
     ssh opc@<ol-vcn-01_PUBLIC_IP>

  4. Passez à l'étape 2 : validation de la prise en charge de la virtualisation par l'environnement

Etapes suivantes

Apprendre à gérer les hôtes et les machines virtuelles avec Oracle Linux Virtual Manager (OLVM)

Ressources de formation supplémentaires

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

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