Criar uma Pilha LAMP de Várias VMs no Oracle Linux KVM

Introdução

O núcleo da solução Oracle Virtualization é o host do Oracle Linux KVM. Além desse hipervisor, você pode executar muitas máquinas virtuais, cada uma executando um dos sistemas operacionais suportados, incluindo Oracle Linux, RHEL, Windows, Ubuntu, Solaris e outros. Essa solução de virtualização é gerenciada por meio do Oracle Linux Virtualization Manager, que oferece uma única interface para manter as coisas organizadas. Além do gerenciamento de vários hosts/multi-VM, o Oracle Linux Virtualization Manager habilita os principais recursos da solução Oracle Virtualization. Por exemplo, o Oracle Linux Virtualization Manager fornece alta disponibilidade automática com failover de VM, migração ao vivo de VMs entre hosts sem tempo de inatividade, controle de acesso baseado em atribuição e log de auditoria, além de workflows de backup e recuperação de desastres simplificados. Esses recursos empresariais transformam o Oracle Linux KVM de hosts individuais em uma verdadeira plataforma de virtualização empresarial.

Neste tutorial, exploraremos a tecnologia principal de hipervisor que potencializa a Oracle Virtualization. O KVM (Kernel-based Virtual Machine) é um hypervisor de código-fonte aberto tipo 1 (bare-metal). Essa funcionalidade permite que um sistema host, como o Oracle Linux, hospede várias máquinas virtuais (VMs) ou convidados ao executar em hardware suportado.

Este tutorial implanta o Oracle Linux KVM para criar máquinas virtuais configuradas com aplicativos de pilha LAMP, permitindo que você hospede ambientes completos de desenvolvimento web com componentes Linux, Apache, MySQL e PHP em várias VMs.

Importante: Os dois códigos de aplicativo neste laboratório são apenas para fins educacionais. Eles são projetados para ajudar os desenvolvedores a aprender e praticar habilidades de desenvolvimento de aplicativos com a pilha LAMP. Esses códigos não se destinam a ambientes de produção e não devem ser usados como estão em uma configuração ativa.

Objetivos

Configurar OCI, Luna ou servidor On-premise
Implantar o Oracle Linux KVM
Criar Máquina Virtual usando Imagens do Oracle Cloud
Instalar o servidor MySQL
Instalar o servidor Web com Apache e PHP

Pré-requisitos

Qualquer sistema Oracle Linux com um usuário não raiz com permissões sudo.

Etapa 1: Implantar o Oracle Linux

Observação: Se estiver em execução na sua própria tenancy, leia o projeto linux-virt-labs GitHub README.md e conclua os pré-requisitos antes de implantar o ambiente de laboratório.

Abra um terminal no Luna Desktop.

Clone o projeto linux-virt-labs GitHub.

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

Altere para o diretório de trabalho.
```
cd linux-virt-labs/ol
```

Instale as coleções necessárias.

ansible-galaxy collection install -r requirements.yml

Implante o ambiente de laboratório.
```
ansible-playbook create_instance.yml -e localhost_python_interpreter="/usr/bin/python3.6" -e instance_ocpus="4" -e instance_memory="64"
```
O ambiente de laboratório gratuito requer a variável extra local_python_interpreter, que define ansible_python_interpreter para reproduções em execução no localhost. Essa variável é necessária porque o ambiente instala o pacote RPM do Oracle Cloud Infrastructure SDK para Python, localizado nos módulos python3.6.

A forma de implantação padrão usa a CPU AMD e o Oracle Linux 8. Para usar uma CPU Intel, adicione -e instance_shape="VM.Standard3.Flex"

Importante: Aguarde a execução bem-sucedida do playbook e atinja a tarefa de pausa. Neste estágio do playbook, a instalação do Oracle Linux está concluída e as instâncias estão prontas. Anote o jogo anterior, que imprime os endereços IP públicos e privados dos nós que ele implanta e quaisquer outras informações de implantação necessárias durante a execução do laboratório.

Etapa 2: Validar Ambiente Suporta Virtualização

Abra um terminal e estabeleça conexão usando SSH com a instância ol-node-01.
```
ssh opc@<ip_address_of_instance>
```
Execute o comando a seguir para determinar seu tipo de CPU.
```
grep -e 'vendor_id' /proc/cpuinfo | uniq
```
O vendor_id reporta AuthenticAMD para uma CPU AMD ou GenuinIntel para uma CPU Intel.
Verifique se o hardware suporta virtualização.

Execute o comando que corresponde ao seu tipo de CPU.
1. Verifique se existem extensões de CPU AMD V.
```
grep -w -o 'svm' /proc/cpuinfo | uniq
```
1. Verifique se existem extensões de CPU Intel VT.
```
grep -w -o 'vmx' /proc/cpuinfo | uniq
```
A existência de um destes sinalizadores na saída do comando indica que este sistema suporta virtualização. Você também pode usar o comando lscpu e procurar a entrada Virtualization na saída.
Verifique os módulos KVM carregados.
```
lsmod | grep kvm
```
A saída exibe os módulos do kernel KVM após a instalação de pacotes de virtualização e o início do serviço libvirtd. Em sistemas de nuvem como o OCI, esses módulos são carregados automaticamente quando o libvirtd é iniciado, não durante a instalação do pacote. A sequência de carregamento é: instalar pacotes → iniciar o serviço libvirtd → módulos aparecem na saída lsmod.

Etapa 3: Instalar e Iniciar o KVM

Verifique a versão em execução do Oracle Linux.
```
hostnamectl | grep 'Operating System'
```
Instale os pacotes de software associados para a virtualização do Oracle Linux.

Este comando instala os pacotes de virtualização, que incluem libvirt e outras dependências no Oracle Linux. O pacote libvirt fornece uma biblioteca de software e uma API para gerenciar máquinas virtuais KVM e inclui o daemon libvirtd que é executado em segundo plano para lidar com o gerenciamento real da VM.
```
sudo dnf module install -y virt
```
Instale o virt-install, uma ferramenta para criar e configurar máquinas virtuais (VMs) usando o hipervisor KVM (Máquina Virtual Baseada em Kernel).
```
sudo dnf install -y virt-install
```
Valide se a máquina host está pronta e configurada para executar VMs libvirt.
```
virt-host-validate
```
Se todas as verificações forem aprovadas, o sistema estará preparado para a criação de VMs. Se alguma verificação falhar, siga as instruções para corrigir o problema. Se qualquer verificação retornar o valor de WARN, considere seguir as instruções para melhorar os recursos de virtualização.
Inicie os serviços Systemd, permitindo que eles sejam iniciados automaticamente em cada inicialização.
```
sudo systemctl enable --now libvirtd.service
```
Verifique o status dos serviços para confirmar se eles estão ativos e em execução.
```
sudo systemctl status libvirtd.service
```
Theutput mostra o serviço como ativado e em execução. Se necessário, insira a letra 'q' para sair do modo de saída.

Etapa 4: Criar duas Máquinas Virtuais usando Imagens do Oracle Cloud

Altere para o local de armazenamento de imagens do KVM.
```
cd /var/lib/libvirt/images
```

Faça download do modelo de VM do Oracle Linux.

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

Criar VM-01 (Banco de Dados)

Criar um arquivo de metadados.

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

Criar um arquivo de dados do usuário.

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

system_info:
  default_user:
    name: opc

ssh_authorized_keys:
  - <paste_public_key_here>
EOF

Gere um par de chaves SSH para conexão segura com a VM.
```
ssh-keygen -t rsa -b 4096
```
Pressione Enter para aceitar cada um dos padrões. O comando grava o par de chaves no diretório .ssh no home do usuário.
Extraia a chave SSH pública gerada.
```
SSHKEY=$(cat ~/.ssh/id_rsa.pub)
```
Atualize o arquivo de dados do usuário com a chave SSH pública gerada.
```
sed -i "s|<paste_public_key_here>|${SSHKEY}|g" ~/user-data
```

Gere uma imagem ISO contendo os arquivos de dados do usuário e metadados.

sudo genisoimage -output /var/lib/libvirt/images/vm-01.iso -volid cidata -joliet -rock ~/user-data ~/meta-data

Localize a variante do SO que corresponde à imagem baixada.
```
osinfo-query os | grep ol8
```

Copie a imagem do Oracle Linux para uma nova imagem de disco para o vm-01.

sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-01.qcow

Crie uma nova máquina virtual chamada vm-01 com recursos e configuração especificados.

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

Liste todas as máquinas virtuais em execução.
```
sudo virsh list
```

Recupere o endereço IP da máquina virtual vm-01.

sudo virsh net-dhcp-leases --network default

Verifique se a máquina virtual funciona conectando-se ao ssh.
```
ssh opc@<ip_address_of_vm-01>
```
Saia do servidor vm-01 para continuar para a próxima etapa.
```
exit
```
Você pode verificar a versão e obter detalhes adicionais sobre o sistema operacional na máquina virtual executando o hostnamectl.

Criar VM-02 (Servidor Web)

Crie um arquivo de metadados para vm-02.

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

Gere uma imagem ISO para vm-02.

sudo genisoimage -output /var/lib/libvirt/images/vm-02.iso -volid cidata -joliet -rock ~/user-data ~/meta-data

Copie a imagem do Oracle Linux para uma nova imagem de disco para o vm-02.

sudo cp /var/lib/libvirt/images/OL8U10_x86_64-kvm-b237.qcow2 /var/lib/libvirt/images/vm-02.qcow

Crie uma nova máquina virtual chamada vm-02 com recursos e configuração especificados.

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

Liste todas as máquinas virtuais em execução.
```
sudo virsh list
```

Recupere o endereço IP da máquina virtual vm-02.

sudo virsh net-dhcp-leases --network default

Verifique se a máquina virtual funciona conectando-se ao ssh.
```
ssh opc@<ip_address_of_vm-02>
```
Saia do servidor vm-01 para continuar para a próxima etapa.
```
exit
```

Você pode verificar a versão e obter detalhes adicionais sobre o sistema operacional na máquina virtual executando o hostnamectl.

hostnamectl

Exemplo de Saída:

[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

Extraia o endereço IP de vm-01.

 VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Extraia o endereço IP de vm-02.

 VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Salve o endereço IP das VMs para uso posterior:

 echo "VM-01 (Web): $VM01_IP"

 echo "VM-02 (Web): $VM02_IP"

Teste o comando SSH para as VMs.

 ssh -o ConnectTimeout=10 opc@$VM01_IP "echo 'VM-01 OK'"

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

Etapa 5: Configurar MySQL no VM-01

Instalar MySQL

Na instância ol-node-01, o SSH estabelece uma conexão SSH com VM-01.
```
 ssh opc@$VM01_IP
```

Faça download da configuração do repositório MySQL.

 sudo yum -y install https://dev.mysql.com/get/mysql84-community-release-el8-1.noarch.rpm

Desative o módulo MySQL padrão para evitar conflitos.
```
 sudo yum -y module disable mysql
```

Instale o servidor e o cliente MySQL.

 sudo yum install -y mysql mysql-server

Inicie o serviço MySQL.
```
 sudo systemctl start mysqld
```
Ative o serviço MySQL para iniciar na inicialização.
```
 sudo systemctl enable mysqld
```
Permita o tráfego de entrada MySQL por meio do firewall.
```
 sudo firewall-cmd --permanent --add-service=mysql
```
Recarregue a configuração do firewall para aplicar as alterações.
```
 sudo firewall-cmd --reload
```
Configurar MySQL

Extraia a senha raiz temporária do log MySQL.

 TEMP_PASS=$(sudo grep 'temporary password' /var/log/mysqld.log | awk '{print $NF}')

Faça login no MySQL com a senha raiz temporária.

 mysql -uroot -p$TEMP_PASS --connect-expired-password

Altere a senha root para um valor seguro.

 ALTER USER 'root'@'localhost' IDENTIFIED BY '[password]';

Crie um usuário 'admin' com uma senha segura.

 CREATE USER 'admin'@'%' IDENTIFIED BY '[password]';

Conceder todos os privilégios ao usuário 'admin'.

 GRANT ALL PRIVILEGES ON *.* TO 'admin'@'%' WITH GRANT OPTION;

Crie um usuário 'empuser' com uma senha segura.

 CREATE USER 'empuser'@'%' IDENTIFIED BY '[password]';

Conceda todos os privilégios a 'empuser'.

 GRANT ALL PRIVILEGES ON *.* TO 'empuser'@'%' WITH GRANT OPTION;

Recarregue tabelas de privilégios para aplicar alterações.
```
 FLUSH PRIVILEGES;
```
Saia do shell MySQL.
```
 \q
```
Saia da sessão SSH em VM-01.
```
 exit
```

Etapa 6: Configurar o Apache/PHP na VM-02

Na instância ol-node-01, o SSH estabelece uma conexão SSH com VM-02.
```
 ssh opc@$VM02_IP
```
Instale o servidor Apache HTTP.
```
 sudo yum install -y httpd
```
Instalar o PHP 8.2 e suas dependências.
```
 sudo dnf install -y @php:8.2
```

Instale as extensões PHP MySQL e JSON.

 sudo yum install -y php-mysqlnd php-json

Ativar e iniciar o servidor Apache HTTP.
```
 sudo systemctl enable --now httpd
```

Permitir tráfego HTTP de entrada na porta 80.

 sudo firewall-cmd --permanent --add-port=80/tcp

Recarregue a configuração do firewall para aplicar as alterações.
```
 sudo firewall-cmd --reload
```
Permitir que o Apache se conecte aos recursos de rede.
```
 sudo setsebool -P httpd_can_network_connect 1
```
Saia da sessão SSH em VM-02.
```
 exit
```

Etapa 7: Testar o Apache

Exiba o endereço IP público de VM-02 YOUR_VM_02_PUBLIC_IP:
```
 echo "VM-02 (Web): $VM02_IP"
```
Abra um novo ambiente Luna ou on-premises do terminal e crie um túnel SSH para acessar o servidor Web VM-02 da máquina local.

… certifique-se de primeiro substituir **** e ****
```
 ssh -L 8081:<YOUR_VM_02_PUBLIC_IP>:80 opc@<YOUR_OCI_PUBLIC_IP>
```
Use um navegador do Luna ou de um ambiente on-premises para testar o Apache acessando o servidor Web por meio do túnel SSH.
```
 http://localhost:8081
```
Importante: Deixe o túnel SSH e o Browser abertos para uso posterior

Etapa 8: Criar Aplicativo de Teste

Retorne à sua instância ssh opc@ol-node-01.

Recupere o endereço IP de VM-01 dos leasings DHCP.

 VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Recupere o endereço IP de VM-02 dos leasings DHCP.

 VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Na instância ol-node-01, o SSH estabelece uma conexão SSH com VM-02.
```
 ssh opc@$VM02_IP
```

Crie uma página de informações PHP para exibir a configuração PHP.

 sudo tee /var/www/html/info.php > /dev/null << 'EOF'
 <?php phpinfo(); ?>
 EOF

Criar aplicativo de teste de conexão de banco de dados.

 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

Defina permissões de arquivo de aplicativo.

 sudo chown apache:apache /var/www/html/*.php

Atualize a linha define('DB_SERVER', '$VM01_IP'); alterando o valor de $VM01_IP com o valor do endereço IP salvo.
```
 sudo vi /var/www/html/dbtest.php
```
Exemplo de Saída:

``texto … Código antes de definir('DB_SERVER', '192.168.122.???'); … Código depois
Saia de VM-02.
```
 exit
```

Etapa 9: Acessar seu aplicativo de Teste do Servidor Web e do Banco de Dados

Se o túnel SSH estiver fechado, crie para teste básico.
```
 ssh -L 8081:$VM02_IP:80 opc@<YOUR_OCI_PUBLIC_IP>
```
Teste básico de LAMP Navegue até:
```
 http://localhost:8081/info.php
```
Demonstração de teste Básico do Banco de Dados Navegue até:
```
http://localhost:8081/dbtest.php
```

Resultados Esperados:

Teste básico: Mensagem verde "Conectado com sucesso ao MySQL!"

Etapa 10: Criar e Carregar Banco de Dados do Funcionário

Você deve estar na sua instância ssh opc@ol-node-01.

Recupere o endereço IP de VM-01 dos leasings DHCP.

 VM01_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-01 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Recupere o endereço IP de VM-02 dos leasings DHCP.

 VM02_IP=$(sudo virsh net-dhcp-leases --network default | grep vm-02 | tail -1 | awk '{print $5}' | cut -d'/' -f1)

Na instância SSH opc@ol-node-01, estabeleça uma conexão SSH com VM-01.
```
 ssh opc@$VM01_IP
```
Altere para a pasta /tmp.
```
 cd /tmp
```

Faça download do banco de dados de amostra de funcionário MySQL.

 curl -L -o master.zip https://github.com/datacharmer/test_db/zipball/master/

Instalar ferramentas de compactação.
```
 sudo dnf install -y unzip
```

Extraia o banco de dados.

 sudo unzip master.zip

 sudo mv datacharmer-test_db-* employees_db

 cd employees_db

Carregue o banco de dados.

 mysql -u admin -p[password] < employees.sql

Verifique o banco de dados carregado.

 mysql -u admin -p[password] -e "USE employees; SHOW TABLES; SELECT COUNT(*) FROM employees;"

Saia da VM do banco de dados.
```
 exit
```

Etapa 11: Criar Aplicativo Web de Banco de Dados do Funcionário

Na instância SSH ol-node-01, estabeleça uma conexão SSH com VM-02.
```
 ssh opc@$VM02_IP
```

Criar aplicativo de banco de dados de funcionários profissionais.

 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

Defina permissões adequadas.

 sudo chown apache:apache /var/www/html/employees.php

Atualize a linha define('DB_SERVER', '$VM01_IP'); alterando o valor de $VM01_IP com o valor do endereço IP salvo.
```
 sudo vi /var/www/html/employees.php
```
Exemplo de Saída:

``texto … Código antes de definir('DB_SERVER', '192.168.122.???'); … Código depois
Saia da VM do servidor Web.
```
 exit
```

Etapa 12: Acessar Aplicação do Funcionário

Se o túnel SSH estiver fechado, crie para teste básico.
```
 ssh -L 8081:$VM02_IP:80 opc@<YOUR_OCI_PUBLIC_IP>
```
Demonstração do Banco de Dados do Funcionário Navegue até:
```
 http://localhost:8081/employees.php
```

Resultados Esperados:

Teste básico: Mensagem verde "Conectado com sucesso ao MySQL!"
Demonstração do funcionário: Interface profissional com mais de 300.000 registros de funcionários

Aplicativos Disponíveis:

🔧 Teste LAMP Básico (`http://localhost:8081/dbtest.php`)

Teste simples de conectividade do banco de dados
Exibição de informações do sistema
Versão e status do MySQL

🏢 Demonstração do banco de dados de funcionários (`http://localhost:8081/employees.php`)

Mais de 300.000 registros de funcionários
Mais de 400.000 registros salariais
Interface profissional com estatísticas
Dados reais para demonstrações
Listagens de departamentos e detalhes do funcionário

Comandos de Gerenciamento Essenciais

Gerenciamento de VMs

Liste as VMs em execução e seus status.
```
 sudo virsh list
```
Inicie VM-01.
```
 sudo virsh start vm-01
```
Desligue VM-01.
```
 sudo virsh shutdown vm-01
```

Exiba os leasings de DHCP para VMs na rede padrão.

 sudo virsh net-dhcp-leases --network default

Configurar para executar este laboratório no Oracle Cloud Infrastructure

Configuração da Rede Virtual na Nuvem: ``` Navegar: Rede → Redes Virtuais na Nuvem → Iniciar Assistente de VCN
- nome: ol-vcn-01
- Criar VCN Navegar: Rede → Redes Virtuais na Nuvem → kvm-network → Listas de Segurança Adicionar estas regras de entrada:
- SSH: Origem 0.0.0.0/0, Porta TCP 22
- HTTP: Origem 0.0.0.0/0, Porta TCP 80 ``

Configuração da Instância de Computação:

     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

Teste o IP público de Computação com SSH.
```
 ssh opc@<ol-vcn-01_PUBLIC_IP>
```
Continue para a Etapa 2: Validar Ambiente Suporta Virtualização.

Próximas Etapas

Aprenda a gerenciar hosts e vms com o Oracle Linux Virtual Manager (OLVM)

Confirmações

Autores - Perside Foster, Bill Graef, Daniel Kingsley
Contribuidores - Oracle VM Product Management (John Priest), Consultor de Vendas Principal (Shawn Kelley), Equipe de Capacitação do Canal para Código Aberto (Nick Mader, Chris Bates, Juliana Castro)

Mais Recursos de Aprendizado

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal do Oracle Learning YouTube. Além disso, acesse education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

Create a Multi-VM LAMP Stack on Oracle Linux KVM

G43726-01

Oracle e/ou suas empresas afiliadas.