O que vamos fazer?

Vamos criar duas máquinas virtuais (uma primária e uma standby) com Oracle Database 19c configurado como Data Guard usando o Vagrant. O repositório do oraclebase automatiza isso, mas precisamos instalar algumas ferramentas e preparar os arquivos antes.

Passo 1: Pré-requisitos

Você precisa instalar algumas coisas no seu computador antes de começar. Vou assumir que você está usando Windows, mas se for Linux ou macOS, me avise que ajusto as instruções.

Instalar o Git:
- Baixe e instale o Git: https://git-scm.com/downloads.
- Durante a instalação, escolha as opções padrão, mas certifique-se de que o "Git Bash" esteja incluído (você vai usar isso para rodar comandos).
Instalar o VirtualBox:
- O Vagrant usa o VirtualBox como provedor padrão para criar VMs. Baixe e instale: https://www.virtualbox.org/wiki/Downloads.
Instalar o Vagrant:
- Baixe e instale o Vagrant: https://www.vagrantup.com/downloads.
- Após instalar, reinicie o computador (às vezes é necessário para o Vagrant funcionar corretamente).
Baixar o software Oracle:
- Você precisa dos arquivos de instalação do Oracle Database 19c. Vá ao site da Oracle: https://www.oracle.com/database/technologies/oracle19c-linux-downloads.html.
- Faça login (crie uma conta se necessário) e baixe:
  - LINUX.X64_193000_db_home.zip (o software básico do Oracle Database 19c).
- Salve esse arquivo em um local fácil de encontrar (ex.: C:\oracle_software).

Passo 2: Clonar o repositório

Agora vamos pegar os arquivos do GitHub e organizar tudo.

Abra o Git Bash:
- No Windows, procure por "Git Bash" no menu Iniciar e abra.
Escolha um diretório:
- Decida onde você quer salvar os arquivos. Por exemplo, vamos usar C:\vagrant_projects. No Git Bash, navegue até lá:
```
  cd /c/vagrant_projects
```
Clone o repositório:
- Execute este comando para baixar os arquivos do GitHub:
```
  git clone https://github.com/oraclebase/vagrant.git
```
- Isso vai criar uma pasta chamada vagrant com todos os projetos do oraclebase.
Navegue até o projeto Data Guard:
- Entre na pasta específica do Data Guard com Oracle Linux 9 e 19c:
```
  cd vagrant/dataguard/ol9_19
```

Passo 3: Preparar o software Oracle

O Vagrant precisa do arquivo do Oracle Database que você baixou.

Crie a pasta software:
- Dentro de vagrant/dataguard/ol9_19, há uma subpasta chamada software. Copie o arquivo LINUX.X64_193000_db_home.zip para lá.
- No Windows, você pode arrastar o arquivo manualmente para C:\vagrant_projects\vagrant\dataguard\ol9_19\software.
- Ou, no Git Bash, use:
```
  cp /c/oracle_software/LINUX.X64_193000_db_home.zip software/
```
Verifique:
- Liste os arquivos na pasta software para confirmar:
```
  ls -la software/
```
- Você deve ver o LINUX.X64_193000_db_home.zip lá.

Passo 4: Configurar e iniciar as VMs

Agora vamos usar o Vagrant para criar e configurar as máquinas virtuais.

Iniciar a VM primária (node1):
- Dentro de vagrant/dataguard/ol9_19, há duas subpastas: node1 (primária) e node2 (standby). Comece pela primária:
```
  cd node1
  vagrant up
```
- Isso vai:
  - Baixar a imagem do Oracle Linux 9 (se ainda não tiver).
  - Criar a VM no VirtualBox.
  - Instalar o Oracle Database 19c e configurar o banco primário.
- Pode demorar um pouco (30-60 minutos, dependendo do seu computador).
Iniciar a VM standby (node2):
- Depois que o node1 terminar (você verá uma mensagem de sucesso no Git Bash), volte um nível e inicie o standby:
```
  cd ../node2
  vagrant up
```
- Isso configura o banco standby e o conecta ao primário via Data Guard.

Passo 5: Verificar o ambiente

Quando os dois vagrant up terminarem, as VMs estarão rodando com o Oracle Data Guard configurado.

Acessar as VMs:
- Para entrar na VM primária:
```
  cd ../node1
  vagrant ssh
```
- Para entrar na VM standby:
```
  cd ../node2
  vagrant ssh
```
Conectar ao banco:
- Dentro de cada VM, você pode se conectar ao Oracle Database como sysdba:
```
  sqlplus / as sysdba
```
- No node1, você verá o banco primário. No node2, o banco standby.

Checar o Data Guard:

No node1 (primário), execute:

  SELECT DEST_ID, STATUS, DESTINATION FROM V$ARCHIVE_DEST WHERE STATUS = 'VALID';

No node2 (standby), verifique o status:

  SELECT DATABASE_ROLE, PROTECTION_MODE FROM V$DATABASE;

Deve mostrar PHYSICAL STANDBY se tudo estiver certo.

Passo 6: Parar ou destruir as VMs (opcional)

Quando terminar de usar:

Parar as VMs:

  vagrant halt  # Dentro de node1 ou node2

Destruir as VMs (remove tudo):

  vagrant destroy -f  # Dentro de node1 ou node2

Dicas e Solução de Problemas

Espaço e memória: Certifique-se de ter pelo menos 8 GB de RAM livre e 50 GB de espaço em disco. Cada VM usa cerca de 4 GB de RAM por padrão.
Erros no vagrant up:
- Se der erro de permissão ou VirtualBox, tente rodar o Git Bash como administrador.
- Se faltar o arquivo Oracle, verifique se ele está na pasta software.
Lento demais: Reduza a memória no Vagrantfile (edite vb.memory = "4096" para algo como 2048 se seu PC for mais fraco).

Resumo

Você instalou o Git, VirtualBox e Vagrant, baixou o software Oracle, clonou o repositório, preparou os arquivos e iniciou as VMs. Agora tem um ambiente Data Guard funcionando! Se precisar de ajuda em algum passo ou quiser testar algo específico (ex.: rodar o ashtop do Tanel Poder), é só me avisar!

Data Guard 19c com Vagrant: Configuração Physical Standby e Broker