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

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 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é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 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 avec un utilisateur non racine doté des autorisations sudo.

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

    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 unité centrale AMD ou GenuinIntel pour une unité centrale 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 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.

    Cette commande installe 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, un outil permettant de créer et de 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

    Theutput indique que le service est 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érez 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. 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é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. 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 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éez 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. Répertoriez 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. 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)

  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érez 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 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
  19. Créez 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
  20. Répertoriez toutes les machines virtuelles en cours d'exécution. 
    sudo virsh list

  21. Extrayez 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 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 '[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'"

É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é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 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. Rechargez la configuration du pare-feu pour appliquer les modifications. 
     sudo firewall-cmd --reload

    Configurer MySQL

  9. Extraire le mot de passe racine temporaire à partir 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. Remplacez le mot de passe racine 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. Accordez 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 '[password]';
  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. Quittez l'interpréteur de commandes MySQL. 
     \q
  18. Quittez la session SSH à partir 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. 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. 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. Rechargez 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. Quittez la session SSH à partir de VM-02. 
     exit

Étape 7 : Tester Apache

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

  2. Ouvrez un nouveau terminal Luna ou un environnement sur place 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_PUBLIC_IP>:80 opc@<YOUR_OCI_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 à l'instance ssh opc@ol-node-01.

  2. Extraire l'adresse IP de VM-01 des contrats de location 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 des contrats de location 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é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é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', '[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éfinition des autorisations relatives aux fichiers 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 sortie :

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

  9. Quittez 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_OCI_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 :

Test de base : Message vert "Réussite de la connexion à MySQL!"

É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 des contrats de location 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 des contrats de location 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. Accédez au dossier /tmp. 
     cd /tmp
  6. Téléchargez la base de données échantillon 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. Extrayez la base de données. 
     sudo unzip master.zip

     sudo mv datacharmer-test_db-* employees_db

     cd employees_db
  9. Charger la base de données. 
     mysql -u admin -p[password] < employees.sql
  10. Vérifiez la base de données 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

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

  1. À partir de l'instance SSH ol-node-01, établissez une connexion SSH à VM-02. 
     ssh opc@$VM02_IP
  2. création d'une application de base de données sur 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 les autorisations appropriées. 
     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 sortie :

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

  5. Quittez 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_OCI_PUBLIC_IP>
  2. Démo de la base de données de l'employé Parcourir pour : 
     http://localhost:8081/employees.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/employees.php)

Commandes de gestion essentielles

Gestion des machines virtuelles

  1. Listez 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. 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)

Remerciements

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.