Crea uno stack LAMP su più VM su Oracle Linux KVM

Introduzione

Alla base della soluzione Oracle Virtualization c'è l'host Oracle Linux KVM. Oltre a questo hypervisor è possibile eseguire molte virtual machine, ognuna delle quali esegue uno dei sistemi operativi supportati, tra cui Oracle Linux, RHEL, Windows, Ubuntu, Solaris e altri. Questa soluzione di virtualizzazione è gestita tramite Oracle Linux Virtualization Manager, che offre un'unica interfaccia per mantenere le cose organizzate. Oltre alla gestione multi-host/multi-VM, Oracle Linux Virtualization Manager consente funzioni chiave della soluzione Oracle Virtualization. Ad esempio, Oracle Linux Virtualization Manager offre l'alta disponibilità automatica con failover VM, migrazione in tempo reale delle VM tra gli host senza tempi di inattività, controllo dell'accesso basato sui ruoli e registrazione dell'audit e flussi di lavoro di backup e disaster recovery semplificati. Queste funzioni aziendali trasformano Oracle Linux KVM da singoli host in una vera e propria piattaforma di virtualizzazione aziendale.

In questa esercitazione esploreremo la tecnologia di base degli hypervisor alla base della virtualizzazione Oracle. KVM (Kernel-based Virtual Machine) è un hypervisor open source di tipo 1 (bare-metal). Questa funzionalità consente a un sistema host, ad esempio Oracle Linux, di ospitare più virtual machine (VM) o guest quando sono in esecuzione su hardware supportato.

Questa esercitazione implementa Oracle Linux KVM per creare macchine virtuali configurate con applicazioni di stack LAMP, consentendoti di ospitare ambienti di sviluppo Web completi con componenti Linux, Apache, MySQL e PHP su più VM.

Importante: i due codici applicazione in questo laboratorio sono solo a scopo didattico. Sono progettati per aiutare gli sviluppatori a imparare e mettere in pratica le competenze di sviluppo delle applicazioni con lo stack LAMP. Questi codici non sono destinati agli ambienti di produzione e non devono essere utilizzati così come sono in un ambiente attivo.

Obiettivi

Prerequisiti

Qualsiasi sistema Oracle Linux con un utente non root con autorizzazioni sudo.

Passo 1: Implementa Oracle Linux

Nota: se è in esecuzione nella propria tenancy, leggere il progetto linux-virt-labs GitHub README.md e completare i prerequisiti prima di distribuire l'ambiente di laboratorio.

  1. Aprire un terminale sul Luna Desktop.

  2. Duplicare il progetto linux-virt-labs GitHub.

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

  3. Passare alla directory di lavoro.

    cd linux-virt-labs/ol

  4. Installare le raccolte richieste.

    ansible-galaxy collection install -r requirements.yml

  5. Implementare l'ambiente di laboratorio.

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

    L'ambiente di esercitazione pratica gratuito richiede l'aggiunta della variabile local_python_interpreter, che imposta ansible_python_interpreter per le riproduzioni eseguite su localhost. Questa variabile è necessaria perché l'ambiente installa il pacchetto RPM per l'SDK Oracle Cloud Infrastructure per Python, situato sotto i moduli python3.6.

    La forma di distribuzione predefinita utilizza la CPU AMD e Oracle Linux 8. Per utilizzare una CPU Intel, aggiungere -e instance_shape="VM.Standard3.Flex"

    Importante: attendere che il playbook venga eseguito correttamente e raggiungere il task di sospensione. In questa fase del playbook, l'installazione di Oracle Linux è completa e le istanze sono pronte. Prendi nota del gioco precedente, che stampa gli indirizzi IP pubblici e privati dei nodi che distribuisce e qualsiasi altra informazione di distribuzione necessaria durante l'esecuzione del laboratorio.

Passo 2: convalidare l'ambiente supporta la virtualizzazione

  1. Aprire un terminale e connettersi utilizzando SSH per l'istanza ol-node-01.

    ssh opc@<ip_address_of_instance>

  2. Eseguire il comando seguente per determinare il tipo di CPU.

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

    vendor_id segnala AuthenticAMD per una CPU AMD o GenuinIntel per una CPU Intel.

  3. Verificare che l'hardware supporti la virtualizzazione.

    Eseguire il comando corrispondente al tipo di CPU.

    1. Verificare che le estensioni CPU AMD V esistano.
    grep -w -o 'svm' /proc/cpuinfo | uniq
    1. Verificare che le estensioni CPU Intel VT esistano.
    grep -w -o 'vmx' /proc/cpuinfo | uniq

    L'esistenza di uno di questi flag nell'output del comando indica che il sistema supporta la virtualizzazione. È anche possibile utilizzare il comando lscpu e cercare la voce Virtualization nell'output.

  4. Controllare la presenza dei moduli KVM caricati.

    lsmod | grep kvm

    L'output visualizza i moduli kernel KVM dopo l'installazione dei pacchetti di virtualizzazione e l'avvio del servizio libvirtd. Su sistemi cloud come OCI, questi moduli si caricano automaticamente all'avvio di libvirtd, non durante l'installazione dei pacchetti. La sequenza di caricamento è: installa i pacchetti → avvia il servizio libvirtd → i moduli appaiono nell'output lsmod.

Passo 3: Installare e avviare KVM

  1. Controllare la versione in esecuzione di Oracle Linux.

    hostnamectl | grep 'Operating System'

  2. Installare i pacchetti software associati per la virtualizzazione Oracle Linux.

    Questo comando installa i pacchetti di virtualizzazione, che includono libvirt e altre dipendenze su Oracle Linux. Il pacchetto libvirt fornisce una libreria software e un'API per gestire le virtual machine KVM e include il daemon libvirtd che viene eseguito in background per gestire la gestione effettiva delle VM.

    sudo dnf module install -y virt

  3. Installare virt-install, uno strumento per la creazione e la configurazione di virtual machine (VM) utilizzando l'hypervisor KVM (Kernel-based Virtual Machine).

    sudo dnf install -y virt-install

  4. Verificare che il computer host sia pronto e configurato per eseguire le VM libvirt.

    virt-host-validate

    Se tutti i controlli vengono superati, il sistema è pronto per la creazione delle VM. Se i controlli non riescono, seguire le istruzioni per risolvere il problema. Se un controllo restituisce il valore di WARN, si consiglia di seguire le istruzioni per migliorare le funzionalità di virtualizzazione.

  5. Avviare i servizi Systemd, consentendo loro di avviarsi automaticamente al boot.

    sudo systemctl enable --now libvirtd.service

  6. Controllare lo stato dei servizi per confermare che sono attivi e in esecuzione.

    sudo systemctl status libvirtd.service

    Theutput mostra il servizio come abilitato e in esecuzione. Se necessario, immettere la lettera 'q' per uscire dalla modalità di output.

Passo 4: creare due virtual machine utilizzando le immagini Oracle Cloud

  1. Passare alla posizione di storage delle immagini KVM.

    cd /var/lib/libvirt/images

  2. Scarica il modello VM Oracle Linux.

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

    Crea VM-01 (database)

  3. Creare un file di metadati.

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

  4. Creare un file di dati utente.

    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. Generare una coppia di chiavi SSH per la connessione sicura alla VM.

    ssh-keygen -t rsa -b 4096

    Premere Enter per accettare le impostazioni predefinite. Il comando scrive la coppia di chiavi nella directory .ssh nella home dell'utente.

  6. Estrae la chiave SSH pubblica generata. 
    SSHKEY=$(cat ~/.ssh/id_rsa.pub)
  7. Aggiornare il file di dati utente con la chiave SSH pubblica generata. 
    sed -i "s|<paste_public_key_here>|${SSHKEY}|g" ~/user-data
  8. Generare un'immagine ISO contenente i file user-data e meta-data. 
    sudo genisoimage -output /var/lib/libvirt/images/vm-01.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
  9. Individuare la variante del sistema operativo corrispondente all'immagine scaricata. 
    osinfo-query os | grep ol8
  10. Copiare l'immagine Oracle Linux in una nuova immagine del disco per vm-01. 
    sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-01.qcow
  11. Creare una nuova virtual machine denominata vm-01 con le risorse e la configurazione specificate. 
    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. Elenca tutte le virtual machine in esecuzione. 
    sudo virsh list

  13. Recupera l'indirizzo IP della virtual machine vm-01.

    sudo virsh net-dhcp-leases --network default

  14. Verificare che la virtual machine funzioni collegandosi a ssh.

    ssh opc@<ip_address_of_vm-01>

  15. Uscire dal server vm-01 per continuare con il passo successivo.

    exit

    È possibile verificare la versione e ottenere ulteriori dettagli sul sistema operativo all'interno della virtual machine eseguendo hostnamectl.

    Crea VM-02 (Web Server)

  16. Creare un file di metadati per vm-02.

    cat << 'EOF' | sudo tee ~/meta-data > /dev/null
instance-id: iid-local02
local-hostname: vm-02
EOF
  17. Generare un'immagine ISO per vm-02. 
    sudo genisoimage -output /var/lib/libvirt/images/vm-02.iso -volid cidata -joliet -rock ~/user-data ~/meta-data
  18. Copiare l'immagine Oracle Linux in una nuova immagine del disco per vm-02. 
    sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-02.qcow
  19. Creare una nuova virtual machine denominata vm-02 con le risorse e la configurazione specificate. 
    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. Elenca tutte le virtual machine in esecuzione. 
    sudo virsh list

  21. Recupera l'indirizzo IP della virtual machine vm-02.

    sudo virsh net-dhcp-leases --network default

  22. Verificare che la virtual machine funzioni collegandosi a ssh.

    ssh opc@<ip_address_of_vm-02>

  23. Uscire dal server vm-01 per continuare con il passo successivo.

    exit

  24. È possibile verificare la versione e ottenere ulteriori dettagli sul sistema operativo all'interno della virtual machine eseguendo hostnamectl.

    hostnamectl

    Output di esempio:

    [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. Estrarre l'indirizzo IP di vm-01. 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  26. Estrarre l'indirizzo IP di vm-02. 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  27. Salvare l'indirizzo IP delle VM per utilizzarlo in un secondo momento: 
     echo "VM-01 (Web): $VM01_IP"

     echo "VM-02 (Web): $VM02_IP"
  28. Eseguire il test del comando SSH per le VM. 
     ssh -o ConnectTimeout=10 opc@$VM01_IP "echo 'VM-01 OK'"

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

Passo 5: installare MySQL su VM-01

Installa MySQL

  1. Dall'istanza ol-node-01 SSH stabilisce una connessione SSH a VM-01. 
     ssh opc@$VM01_IP
  2. Scaricare la configurazione del repository MySQL. 
     sudo yum -y install https://dev.mysql.com/get/mysql84-community-release-el8-1.noarch.rpm
  3. Disabilitare il modulo MySQL predefinito per evitare conflitti. 
     sudo yum -y module disable mysql
  4. Installare il server e il client MySQL. 
     sudo yum install -y mysql mysql-server
  5. Avviare il servizio MySQL. 
     sudo systemctl start mysqld
  6. Attivare il servizio MySQL per avviarlo al boot. 
     sudo systemctl enable mysqld
  7. Consenti traffico MySQL in entrata attraverso il firewall. 
     sudo firewall-cmd --permanent --add-service=mysql
  8. Ricaricare la configurazione del firewall per applicare le modifiche. 
     sudo firewall-cmd --reload

    Configura MySQL

  9. Estrarre la password root temporanea dal log MySQL. 
     TEMP_PASS=$(sudo grep 'temporary password' /var/log/mysqld.log | awk '{print $NF}')
  10. Eseguire il login a MySQL con password root temporanea. 
     mysql -uroot -p$TEMP_PASS --connect-expired-password
  11. Impostare la password root su un valore sicuro. 
     ALTER USER 'root'@'localhost' IDENTIFIED BY '[password]';
  12. Creare un utente 'admin' con una password sicura. 
     CREATE USER 'admin'@'%' IDENTIFIED BY '[password]';
  13. Concedi tutti i privilegi all'utente 'admin'. 
     GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;
  14. Creare un utente 'empuser' con una password sicura. 
     CREATE USER 'empuser'@'%' IDENTIFIED BY '[password]';
  15. Concedere tutti i privilegi a 'empuser'. 
     GRANT ALL PRIVILEGES ON *.* TO 'empuser'@'%' WITH GRANT OPTION;
  16. Ricarica le tabelle dei privilegi per applicare le modifiche. 
     FLUSH PRIVILEGES;
  17. Uscire dalla shell MySQL. 
     \q
  18. Uscire dalla sessione SSH da VM-01. 
     exit

Passaggio 6: installare Apache/PHP su VM-02

  1. Dall'istanza ol-node-01 SSH stabilisce una connessione SSH a VM-02. 
     ssh opc@$VM02_IP
  2. Installare il server Apache HTTP. 
     sudo yum install -y httpd
  3. Installare PHP 8.2 e le relative dipendenze. 
     sudo dnf install -y @php:8.2
  4. Installare le estensioni PHP MySQL e JSON. 
     sudo yum install -y php-mysqlnd php-json
  5. Abilitare e avviare il server Apache HTTP. 
     sudo systemctl enable --now httpd
  6. Consenti traffico HTTP in entrata sulla porta 80. 
     sudo firewall-cmd --permanent --add-port=80/tcp
  7. Ricaricare la configurazione del firewall per applicare le modifiche. 
     sudo firewall-cmd --reload
  8. Consenti a Apache di connettersi alle risorse di rete. 
     sudo setsebool -P httpd_can_network_connect 1
  9. Uscire dalla sessione SSH da VM-02. 
     exit

Passo 7: Test di Apache

  1. Visualizza l'indirizzo IP pubblico di VM-02 YOUR_VM_02_PUBLIC_IP: 
     echo "VM-02 (Web): $VM02_IP"

  2. Aprire un nuovo terminale Luna o ambiente in locale e creare un tunnel SSH per accedere al server Web VM-02 dal computer locale.

    … assicurati di sostituire prima **** e ****

     ssh -L 8081:<YOUR_VM_02_PUBLIC_IP>:80 opc@<YOUR_OCI_PUBLIC_IP>
  3. Utilizzare un browser da Luna o un ambiente in locale per eseguire il test di Apache accedendo al server Web tramite il tunnel SSH. 
     http://localhost:8081

    Importante: lasciare aperti il tunnel SSH e il browser per un uso successivo

Passo 8: creare l'applicazione di test

  1. Tornare all'istanza ssh opc@ol-node-01.

  2. Recupera l'indirizzo IP di VM-01 dai leasing DHCP. 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Recupera l'indirizzo IP di VM-02 dai leasing DHCP. 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. Dall'istanza ol-node-01 SSH stabilisce una connessione SSH a VM-02. 
     ssh opc@$VM02_IP
  5. Creare una pagina di informazioni PHP per visualizzare la configurazione PHP. 
     sudo tee /var/www/html/info.php > /dev/null << 'EOF'
 <?php phpinfo(); ?>
 EOF

  6. Crea l'applicazione di test della connessione al database.

     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. Impostare le autorizzazioni per i file dell'applicazione. 
     sudo chown apache:apache /var/www/html/*.php
  8. Aggiornare la riga define('DB_SERVER', '$VM01_IP'); modificando il valore $VM01_IP con il valore dell'indirizzo IP salvato. 
     sudo vi /var/www/html/dbtest.php

    Output di esempio:

    ``testo … codice prima di definire('DB_SERVER', '192.168.122???'); … codice dopo

  9. Uscire da VM-02.

     exit

Passo 9: accedere all'applicazione di test del server Web e del database

  1. Se il tunnel SSH viene chiuso, creare per il test di base. 
     ssh -L 8081:$VM02_IP:80 opc@<YOUR_OCI_PUBLIC_IP>
  2. Prova LAMP di base Sfoglia per: 
     http://localhost:8081/info.php
  3. Demo di test del database di base Cerca in: 
    http://localhost:8081/dbtest.php

Risultati previsti:

Test di base: messaggio verde "Connesso a MySQL!"

Passo 10: creazione e caricamento del database dipendenti

  1. È necessario trovarsi nell'istanza ssh opc@ol-node-01.

  2. Recupera l'indirizzo IP di VM-01 dai leasing DHCP. 
     VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  3. Recupera l'indirizzo IP di VM-02 dai leasing DHCP. 
     VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)
  4. Dall'istanza SSH opc@ol-node-01, stabilire una connessione SSH a VM-01. 
     ssh opc@$VM01_IP
  5. Passare alla cartella /tmp. 
     cd /tmp
  6. Scaricare il database di esempio dei dipendenti MySQL. 
     curl -L -o master.zip https://github.com/datacharmer/test_db/zipball/master/
  7. Installare strumenti di compressione. 
     sudo dnf install -y unzip
  8. Estrarre il database. 
     sudo unzip master.zip

     sudo mv datacharmer-test_db-* employees_db

     cd employees_db
  9. Caricamento del database. 
     mysql -u admin -p[password] < employees.sql
  10. Verificare il database caricato. 
     mysql -u admin -p[password] -e "USE employees; SHOW TABLES; SELECT COUNT(*) FROM employees;"
  11. Uscire dalla VM di database. 
     exit

Passo 11: creazione applicazione Web database dipendenti

  1. Dall'istanza SSH ol-node-01, stabilire una connessione SSH a VM-02. 
     ssh opc@$VM02_IP
  2. Crea un'applicazione professionale per il database dei dipendenti. 
     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. Impostare le autorizzazioni corrette. 
     sudo chown apache:apache /var/www/html/employees.php
  4. Aggiornare la riga define('DB_SERVER', '$VM01_IP'); modificando il valore $VM01_IP con il valore dell'indirizzo IP salvato. 
     sudo vi /var/www/html/employees.php

    Output di esempio:

    ``testo … codice prima di definire('DB_SERVER', '192.168.122???'); … codice dopo

  5. Uscire dalla VM del server Web. 
     exit

Passo 12: accedere all'applicazione dipendente

  1. Se il tunnel SSH viene chiuso, creare per il test di base. 
     ssh -L 8081:$VM02_IP:80 opc@<YOUR_OCI_PUBLIC_IP>
  2. Demo del database dei dipendenti Sfoglia per: 
     http://localhost:8081/employees.php

Risultati previsti:

Applicazioni disponibili:

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

🏢 Demo del database dei dipendenti (http://localhost:8081/employees.php)

Comandi di gestione essenziali

Gestione VM

  1. Elenca le VM in esecuzione e il relativo stato. 
     sudo virsh list
  2. Avviare VM-01. 
     sudo virsh start vm-01
  3. Arrestare VM-01. 
     sudo virsh shutdown vm-01
  4. Visualizza i lease DHCP per le VM nella rete predefinita. 
     sudo virsh net-dhcp-leases --network default

Impostazione Per eseguire questo laboratorio su Oracle Cloud Infrastructure

  1. Impostazione della rete cloud virtuale: ``` Naviga: Networking → Reti cloud virtuali → Avvia procedura guidata VCN
    • Nome: ol-vcn-01
    • Creare una VCN Navigare: Networking → Reti cloud virtuali → kvm-network → Liste di sicurezza Aggiungere queste regole di entrata:
    • SSH: origine 0.0.0.0/0, porta TCP 22
    • HTTP: origine 0.0.0.0/0, porta TCP 80 ```
  2. Impostazione istanza di computazione: 
         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. Eseguire il test dell'IP pubblico di computazione con SSH. 
     ssh opc@<ol-vcn-01_PUBLIC_IP>
  4. Passare al passo 2: Convalida che l'ambiente supporti la virtualizzazione.

Passi successivi

Impara a gestire host e vms con Oracle Linux Virtual Manager (OLVM)

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.

Per la documentazione del prodotto, visitare Oracle Help Center.