Création d'une pile LAMP à plusieurs machines virtuelles sur Oracle Linux KVM

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 déploie Oracle Linux KVM pour créer des machines virtuelles configurées avec des applications de pile LAMP, ce qui vous permet 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 un utilisateur non root disposant des droits d'accès sudo.

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 sur le 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 terminal et connectez-vous à l'instance ol-node-01 à l'aide de SSH.

    ssh opc@<ip_address_of_instance>

  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 que 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.

    Cette commande installe 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, un 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 vous assurer qu'ils sont en fonctionnement.

    sudo systemctl status libvirtd.service

    Theutput indique que le service a été activé et exécuté. 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érez une paire de clés SSH pour la 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. Extrayez la clé SSH publique générée. 
    SSHKEY=$(cat ~/.ssh/id_rsa.pub)
  7. Mettez à 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érez 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. Recherchez la variante du système d'exploitation correspondant à l'image téléchargée. 
    osinfo-query os | grep ol8
  10. Copiez l'image Oracle Linux vers une nouvelle image de 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éez une machine virtuelle nommée vm-01 avec les ressources et la configuration indiqué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épertoriez 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. Quittez 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)

  16. Créez 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
  17. 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
  18. Copiez 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
  19. Créez une machine virtuelle nommée vm-02 avec les ressources et la configuration indiqué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
  20. Répertoriez toutes les machines virtuelles en cours d'exécution. 
    sudo virsh list

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

    sudo virsh net-dhcp-leases --network default

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

    ssh opc@<ip_address_of_vm-02>

  23. Quittez le serveur vm-01 pour passer à l'étape suivante.

    exit

  24. 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 '[host]' can't be established.
ECDSA key fingerprint is [fingerprint].
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[IP]' (ECDSA) to the list of known hosts.

[opc@vm-01 ~]$ hostnamectl
   Static hostname: vm-01
         Icon name: computer-vm
           Chassis: vm
        Machine ID: [MachineID]
           Boot ID: [BootID]
    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
  25. Extraire l'adresse IP de vm-01. 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  26. Extraire l'adresse IP de vm-02. 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  27. Enregistrez l'adresse IP des machines virtuelles pour une utilisation ultérieure : 
     echo "VM-01 (Web): $VM01_IP"

     echo "VM-02 (Web): $VM02_IP"
  28. Testez 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échargez 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ésactivez le module MySQL par défaut pour éviter les conflits. 
     sudo yum -y module disable mysql
  4. Installez le serveur et le client MySQL. 
     sudo yum install -y mysql mysql-server
  5. Démarrez le service MySQL. 
     sudo systemctl start mysqld
  6. Activez le démarrage du service MySQL à l'initialisation. 
     sudo systemctl enable mysqld
  7. Autorisez le trafic MySQL entrant via le pare-feu. 
     sudo firewall-cmd --permanent --add-service=mysql
  8. Rechargez la configuration du pare-feu pour appliquer les modifications. 
     sudo firewall-cmd --reload

    Configurer MySQL

  9. Extrayez 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 un mot de passe root temporaire. 
     mysql -uroot -p$TEMP_PASS --connect-expired-password
  11. Remplacez le mot de passe root par une valeur sécurisée. 
     ALTER USER 'root'@'localhost' IDENTIFIED BY '[password]';
  12. Créez un utilisateur 'admin' avec un mot de passe sécurisé. 
     CREATE USER 'admin'@'%' IDENTIFIED BY '[password]';
  13. Accorder tous les privilèges à l'utilisateur 'admin'. 
     GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;
  14. Créez un utilisateur "empuser" avec un mot de passe sécurisé. 
     CREATE USER 'empuser'@'%' IDENTIFIED BY '[password]';
  15. Accordez tous les privilèges à 'empuser'. 
     GRANT ALL PRIVILEGES ON *.* TO 'empuser'@'%' WITH GRANT OPTION;
  16. Rechargez les tables de privilèges pour appliquer les modifications. 
     FLUSH PRIVILEGES;
  17. Quittez le shell MySQL. 
     \q
  18. Quittez 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. Installez le serveur Apache HTTP. 
     sudo yum install -y httpd
  3. Installez PHP 8.2 et ses dépendances. 
     sudo dnf install -y @php:8.2
  4. Installez les extensions PHP MySQL et JSON. 
     sudo yum install -y php-mysqlnd php-json
  5. Activez et démarrez 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. Rechargez la configuration du pare-feu pour appliquer les modifications. 
     sudo firewall-cmd --reload
  8. Autorisez Apache à se connecter aux ressources réseau. 
     sudo setsebool -P httpd_can_network_connect 1
  9. Quittez la session SSH à partir de VM-02. 
     exit

Etape 7 : test d'Apache

  1. Affichez l'adresse IP publique de VM-02 YOUR_VM_02_PUBLIC_IP : 
     echo "VM-02 (Web): $VM02_IP"

  2. Ouvrez un nouvel environnement terminal Luna ou sur site et créez 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_PUBLIC_IP>:80 opc@<YOUR_OCI_PUBLIC_IP>
  3. Utilisez 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. Revenez à 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éez 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éez 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', '[password]');
 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éfinissez 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 enregistrée. 
     sudo vi /var/www/html/dbtest.php

    Exemple de résultat :

    "`text … Code before define('DB_SERVER', '192.168.122. ? ? ?') ; … Code after

  9. Quittez 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 un test de base. 
     ssh -L 8081:$VM02_IP:80 opc@<YOUR_OCI_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:

Test de base : message vert "Successfully Connected to MySQL !"

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

  1. Vous devez vous trouver dans 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 SSH opc@ol-node-01, établissez une connexion SSH à VM-01. 
     ssh opc@$VM01_IP
  5. Accédez au dossier /tmp. 
     cd /tmp
  6. Téléchargez la base de données exemple d'employé MySQL. 
     curl -L -o master.zip https://github.com/datacharmer/test_db/zipball/master/
  7. Installez les outils de compression. 
     sudo dnf install -y unzip
  8. Extraire la base de données. 
     sudo unzip master.zip

     sudo mv datacharmer-test_db-* employees_db

     cd employees_db
  9. Chargez la base de données. 
     mysql -u admin -p[password] < employees.sql
  10. Vérifiez que la base de données est chargée. 
     mysql -u admin -p[password] -e "USE employees; SHOW TABLES; SELECT COUNT(*) FROM employees;"
  11. Quittez 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 SSH ol-node-01, établissez 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/employees.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', '[password]');
     define('DB_NAME', 'employees');

     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 employees");
         $stats['employees'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM departments");
         $stats['departments'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM salaries");
         $stats['salaries'] = $stmt->fetch()['count'];
            
         $stmt = $pdo->query("SELECT COUNT(*) as count FROM titles");
         $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['employees']) . '</div><div>Employees</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 employees
         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 employees ORDER BY hire_date DESC LIMIT 20");
         $employees = $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 ($employees 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 departments 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+ employees, 400,000+ salary records</p>
     </div>
 </body>
 </html>
 EOF
  3. Définissez des droits d'accès appropriés. 
     sudo chown apache:apache /var/www/html/employees.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/employees.php

    Exemple de résultat :

    "`text … Code before define('DB_SERVER', '192.168.122. ? ? ?') ; … Code after

  5. Quittez la machine virtuelle du serveur Web. 
     exit

Etape 12 : Accès à l'application Employee

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

Résultats attendus:

Applications disponibles :

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

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

Commandes de gestion essentielles

Gestion des machines virtuelles

  1. Répertoriez les machines virtuelles en cours d'exécution et leur statut. 
     sudo virsh list
  2. Démarrez VM-01. 
     sudo virsh start vm-01
  3. Arrêtez 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. Testez l'adresse IP publique Compute avec SSH. 
     ssh opc@<ol-vcn-01_PUBLIC_IP>
  4. Passez à l'étape 2 : Valider l'environnement prend en charge la virtualisation.

Etapes suivantes

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

Accusés de réception

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.