Note :

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

Présentation

Au cœur de la solution Oracle Virtualization se trouve l'hôte Oracle Linux KVM. En plus de cet hyperviseur, vous pouvez exécuter de nombreuses machines virtuelles, chacune exécutant un des systèmes d'exploitation pris en charge, y compris Oracle Linux, RHEL, Windows, Ubuntu, Solaris et d'autres. Cette solution de virtualisation est gérée par l'intermédiaire d'Oracle Linux Virtualization Manager, qui offre une interface unique pour garder les choses organisées. En plus de la gestion multi-hôtes/multi-VM, Oracle Linux Virtualization Manager offre des fonctions clés de la solution Oracle Virtualization. Par exemple, Oracle Linux Virtualization Manager offre une haute disponibilité automatique avec basculement de machine virtuelle, une migration en direct des machines virtuelles entre les hôtes sans temps d'arrêt, un contrôle d'accès basé sur les rôles et une journalisation de vérification, ainsi que des flux de travail simplifiés de sauvegarde et de reprise après sinistre. Ces fonctions d'entreprise transforment Oracle Linux KVM d'hôtes individuels en une véritable plate-forme de virtualisation d'entreprise.

Dans ce tutoriel, nous explorerons la technologie de base de l'hyperviseur qui alimente Oracle Virtualization. KVM (Kernel-based Virtual Machine) est un hyperviseur à code source libre 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 lors de l'exécution sur du matériel pris en charge.

Ce tutoriel déploiera 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 ce laboratoire sont fournis à des fins éducatives seulement. Ils sont conçus pour aider les développeurs à apprendre et à pratiquer les 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 de production.

Objectifs

Conditions requises

Tout système Oracle Linux ayant les configurations suivantes :

Étape 1 : Déployer Oracle Linux

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.

  1. Ouvrez un terminal à partir du Luna Desktop.

  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 collections requises.

    ansible-galaxy collection install -r requirements.yml

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

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

    L'environnement de laboratoire gratuit nécessite 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 l'ensemble RPM pour la trousse SDK Oracle Cloud Infrastructure pour Python, située 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, ajoutez -e instance_shape="VM.Standard3.Flex"

    Important : Attendez que le livre de jeu s'exécute avec succès et atteignez la tâche Mettre en pause. À ce stade du livre de jeu, l'installation d'Oracle Linux est terminée 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 et toutes les autres informations de déploiement nécessaires lors de l'exécution de l'exercice.

Étape 2 : La validation de l'environnement prend en charge la virtualisation

  1. Ouvrez un nouveau terminal à partir de Luna Desktop 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 unité centrale AMD ou GenuinIntel pour une unité centrale 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 processeur Intel VT existent.
    grep -w -o 'vmx' /proc/cpuinfo | uniq

    L'existence d'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 du noyau KVM après l'installation des packages de virtualisation et le démarrage du service libvirtd. Sur des systèmes en nuage tels qu'OCI, ces modules se chargent automatiquement au démarrage de libvirtd et non lors de l'installation du paquetage. La séquence de chargement est : installer les paquets → démarrer le service libvirtd → les modules apparaissent dans la sortie lsmod.

Étape 3 : Installer et démarrer KVM

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

    hostnamectl | grep 'Operating System'

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

    Ces commandes installent les ensembles de virtualisation, qui incluent libvirt, et d'autres dépendances sur Oracle Linux. Le paquet libvirt fournit une bibliothèque de logiciels et une API pour gérer les machines virtuelles KVM et comprend 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 pour créer et configurer des 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êt à créer des machines virtuelles. Si des vérifications échouent, suivez les instructions pour corriger le problème. Si une vérification retourne 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 démarrage.

    sudo systemctl enable --now libvirtd.service

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

    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

Étape 4 : Créer deux machines virtuelles à l'aide d'images Oracle Cloud

  1. Accédez à l'emplacement de stockage des images 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 machine virtuelle-01 (base de données)

  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 d'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 dans 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éer une nouvelle 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. Lister toutes les machines virtuelles en cours d'exécution 
    sudo virsh list

  13. Extrayez 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. 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 dans 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 dans 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 nouvelle 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. Lister toutes les machines virtuelles en cours d'exécution 
    sudo virsh list

  22. Extrayez 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. Quittez 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 dans la machine virtuelle en exécutant hostnamectl.

    hostnamectl

    Exemple de sortie :

    [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. Extraire l'adresse IP de vm-01 et l'enregistrer 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. Extraire l'adresse IP de vm-02 et l'enregistrer 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 enregistrée correctement : 
     echo "VM-01 (Web): $VM01_IP"

     echo "VM-02 (Web): $VM02_IP"
  30. Tester 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'"

Étape 5 : Configurer MySQL sur VM-01

Installer MySQL

  1. À 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 service MySQL pour démarrer au démarrage 
     sudo systemctl enable mysqld
  7. Autoriser le trafic MySQL entrant au moyen du 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 racine 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 racine temporaire 
     mysql -uroot -p$TEMP_PASS --connect-expired-password
  11. Modifier le mot de passe racine à une valeur sécurisée 
     ALTER USER 'root'@'localhost' IDENTIFIED BY 'Welcome#123';
  12. Créer un utilisateur 'administrateur' 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 l'interpréteur de commandes MySQL 
     \q
  18. Quitter la session SSH de VM-01 
     exit

Étape 6 : Configurer Apache/PHP sur VM-02

  1. À partir de l'instance ol-node-01, SSH établit une connexion SSH à VM-02 
     ssh opc@$VM02_IP
  2. Installer le 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 les 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 de réseau 
     sudo setsebool -P httpd_can_network_connect 1
  9. Quitter la session SSH de VM-02 
     exit

Étape 7 : Tester Apache

  1. Afficher l'adresse IP de VM-02 VOTRE VM_02 IP : 
     echo "VM-02 (Web): $VM02_IP"

  2. Ouvrez un nouveau terminal à partir de Luna Desktop et créez un tunnel SSH pour accéder au serveur Web VM-02 à partir d'une machine locale

    … assurez-vous de remplacer **** et ****

     ssh -L 8081:<YOUR VM_02 IP>:80 opc@<YOUR ol-node-01 PUBLIC_IP>
  3. Utilisez un navigateur à partir de Luna ou de l'environnement sur place pour tester Apache en accédant au serveur Web au moyen du tunnel SSH 
     http://localhost:8081

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

Étape 8 : Créer une application de test

  1. Retournez à votre instance ssh opc@ol-node-01

  2. Extraire l'adresse IP de VM-01 à partir des baux DHCP 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Extraire l'adresse IP de VM-02 à partir des baux DHCP 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. À 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 de fichier d'application 
     sudo chown apache:apache /var/www/html/*.php
  8. Mettre à 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 sortie :

    "`text … Code avant definition('DB_SERVER', '$VM01_IP'); … Code après definition('DB_SERVER', '192.168.122.???");

  9. Quitter VM-02

     exit

Étape 9 : Accéder à l'application Webserver et Database Test

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

Résultats prévus :

Étape 10 : Créer et charger la base de données de l'employé

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

  2. Extraire l'adresse IP de VM-01 à partir des baux DHCP 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Extraire l'adresse IP de VM-02 à partir des baux DHCP 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. À partir de l'instance SSH opc@ol-node-01, établissez une connexion SSH à VM-01 
     ssh opc@$VM01_IP
  5. Modifier au dossier /tmp 
     cd /tmp
  6. Télécharger la base de données-échantillons 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 des 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 la base de données chargée 
     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

Étape 11 : Créer une application Web de base de données d'employé

  1. À 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 autorisations appropriées 
     sudo chown apache:apache /var/www/html/employee.php
  4. Mettre à 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 sortie :

    "`text … Code avant definition('DB_SERVER', '$VM01_IP'); … Code après definition('DB_SERVER', '192.168.122.???");

  5. Quitter la machine virtuelle du serveur Web 
     exit

Étape 12 : Accéder à l'application Employee

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

Résultats prévus :

Applications disponibles :

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

🏢 Démo de la base de données de l'employé (http://localhost:8081/employee.php)

Commandes de gestion essentielles

Gestion des machines virtuelles

  1. Liste des 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. Afficher les contrats de location DHCP pour les machines virtuelles sur le réseau par défaut 
     sudo virsh net-dhcp-leases --network default

Configuration pour exécuter ce laboratoire sur Oracle Cloud Infrastructure

  1. Configuration du réseau en nuage virtuel ``` Naviguer : Réseau → Réseaux en nuage virtuels → Démarrer l'Assistant VCN
    • Nom : ol-vcn-01
    • Créer un VCN Naviguer : Réseau → Réseaux en nuage virtuels → kvm-network → Listes de sécurité Ajouter ces règles de trafic entrant :
    • SSH : Source 0.0.0.0/0, port TCP 22
    • HTTP : Source 0.0.0.0/0, port TCP 80 ``
  2. Configuration d'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 de calcul avec SSH 
     ssh opc@<ol-vcn-01_PUBLIC_IP>

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

Étapes suivantes

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

Ressources d'apprentissage supplémentaires

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.