Was ist Vagrant?
Vagrant ist eine von der Firma HashiCorp entwickelte Applikation zur Einrichtung und Verwaltung virtueller Maschinen.
Es handelt sich um eine Software, die den Anwender bei der Erstellung von VMs unterstützt, diesen Prozess erleichtert und über eine Konfigurationsdatei den Aufbau gleicher Umgebungen für die verschiedenen Stages einer Systemumgebung (Entwicklung, Test, …, Integration, Produktion) sicherstellt.
Überblick
In diesem Dokument wird die Verwendung von Vagrant zum Aufbau von VMs auf einem Laptop mit Windows 10 Betriebssystem beispielhaft dargestellt, sodass der Leser durch Nachvollziehen der verschiedenen Schritte in die Benutzung von Vagrant eingeführt wird.
In einem ersten Beispiel wird eine sehr rudimentäre VM erstellt, die man bezüglich Einfachheit in etwa mit den vielen „Hello World“ Beispielen im Zusammenhang mit der Einführung in unterschiedliche Programmiersprachen betrachten kann.
Im zweiten Beispiel werden zwei VMs eingerichtet, in denen über Vagrant jeweils die Oracle RDBMS Software in der Version 19.3 installiert wird. Auf dem ersten dieser beiden Knoten wird durch Vagrant eine Datenbank als Primary und auf dem zweiten Knoten die zugehörige Standby DB eingerichtet.
Vagrant ist für folgende Betriebssysteme verfügbar:
- macOS Amd64
- Windows 686 ( hier verwendet ) und Amd64
- Unix-Derivate
- Linux Amd64
- Debian 686 und Amd64
- CentOS 686 und Amd64
- Arch Linux Amd64
Vagrant arbeitet mit verschiedenen Virtualisierungsumgebungen („Providers“). Die wohl bekanntesten sind
- Oracle VirtualBox ( hier verwendet )
- VMWare
- Hyper-V
- Docker
Vorbereitung
Bevor wir beginnen kommen wir zu den vorbereitenden Maßnahmen. Folgende Software wurde für diesen Artikel verwendet:
Download-URLhttps://git-scm.com/download/winhttps://www.vagrantup.com/downloadshttps://www.virtualbox.org/wiki/Downloadshttps://www.oracle.com/database/technologies/oracle19c-linux-downloads.html
Die Installationen von Git, Vagrant und Virtual Box erfolgen durch einen Wizard auf einem Windows Laptop und werden hier nicht weiter beschrieben.
Git wurde hier lediglich eingesetzt, um initial die DataGuard Konfigurationsskripte von Tim Hall zu laden.
Die Installation der Oracle Datenbank-Software und die Konfiguration als DataGuard erfolgen skriptgesteuert innerhalb der VMs durch Vagrant.
Vagrant und die Programmiersprache Ruby
Vagrant wurde in der Programmiersprache Ruby implementiert und wird durch eine Ruby-Datei mit dem Namen „Vagrantfile“ gesteuert. Ruby-Kenntnisse werden i.d.R. nicht benötigt, um das Tool zu nutzen. Das Vagrantfile sollte sich in dem aktuellen Verzeichnis befinden, in dem man sich beim Aufruf von Vagrant befindet. Dort startet man den Aufbau der VM durch den folgenden Befehl:
PS C:\Vagrant_VM_Setup> vagrant up
Wird im aktuellen Verzeichnis keine Datei mit dem geforderten Namen gefunden, so sucht Vagrant diese iterativ in den übergeordneten Verzeichnissen, bis eine entsprechende Datei gefunden wurde oder die Wurzel des Dateibaums erreicht ist. Wird eine solche Datei nicht gefunden, so erhält man die folgende Meldung:
PS C:\Vagrant_VM_Setup> vagrant up
A Vagrant environment or target machine is required to run this
command. Run `vagrant init` to create a new Vagrant environment. Or,
get an ID of a target machine from `vagrant global-status` to run
this command on. A final option is to change to a directory with a
Vagrantfile and to try again.
Boxes
Entwickler können sich unter Vagrant Cloud registrieren und ihre VMs als Templates für den privaten oder öffentlichen Gebrauch hochladen. Die veröffentlichten VMs, in HashiCorp / Vagrant als „Boxes“ bezeichnet, sind unter Vagrant Cloud by HashiCorp über eine Suchfunktion erreichbar. Das Hochladen öffentlicher, für alle verwendbaren VMs ist kostenlos („Unlimited public boxes“).
In diesem Dokument wird entsprechend dem üblichen Sprachgebrauch der Begriff “Box” verwendet, wenn ein nach HashiCorp hochgeladenes Template gemeint ist. Andernfalls wird “VM” als Bezeichnung für eine heruntergeladene und in Virtualbox verfügbare virtuelle Maschine verwendet.
Beispiele
Zur Bearbeitung der beiden Beispiele wurde die PowerShell verwendet. Da keine PowerShell spezifischen Befehle benötigt werden, kann alternativ auch die klassische DOS/CMD-Shell verwendet werden.
Im oben angegebenen Fall, in dem das Kommando „vagrant up“ verwendet wurde, war das Verzeichnis C:\Vagrant_VM_Setup leer und wir kommen damit zu dem ersten Beispiel. Wie in der oben stehenden Meldung angegeben, kann über den Befehl „vagrant init“ eine neue Vagrant Umgebung eingerichtet werden.
Beispiel 1: Einrichten einer rudimentären VM
Zunächst wird ein leeres Verzeichnis erstellt, in dem die Vagrant-Steuerdateien abgelegt werden.
PS C:\> md Vagrant_VM_Setup
Verzeichnis: C:\
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 18.07.2022 10:43 Vagrant_VM_Setup
Innerhalb dieses Verzeichnisses wird die init-Option verwendet, um eine initiale Vagrantfile Datei anzulegen. Ein über init angelegtes Vagrantfile enthält viele Kommentare und auskommentierte Einstellungsmöglichkeiten die hier über die -m Option ausgefiltert werden. Dem Leser wird empfohlen, die -m Option wegzulassen und sich den Inhalt der Datei anzusehen. Der Aufrufparameter hashicorp/bionic64 bezeichnet den Namen einer der vielen von der Firma HashiCorp bereitgestellten Boxes (=VMs). Bionic ist die offizielle Bezeichnung der Ubuntu Version 18.04.
PS C:\> cd .\Vagrant_VM_Setup\
PS C:\Vagrant_VM_Setup> vagrant init -m hashicorp/bionic64
A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.
Als Ergebnis des init-Aufrufs erhalten wir im aktuellen Verzeichnis eine Vagrantfile-Datei mit folgendem Inhalt:
# -*- mode: ruby -*-
# vi: set ft=ruby :
Vagrant.configure("2") do |config|
config.vm.box = "hashicorp/bionic64"
end
Jetzt kann bereits unsere erste VM mit dem folgenden Befehl gestartet werden. Dies benötigt inklusive Download der angegebenen hashicorp/bionic64 VM je nach vorliegender Download- und Rechnergeschwindigkeit ca. 1-2 Minuten:
PS C:\Vagrant_VM_Setup> vagrant up
Bringing machine 'default' up with 'virtualbox' provider...
==> default: Box 'hashicorp/bionic64' could not be found. Attempting to find and install...
default: Box Provider: virtualbox
default: Box Version: >= 0
==> default: Loading metadata for box 'hashicorp/bionic64'
default: URL: https://vagrantcloud.com/hashicorp/bionic64
==> default: Adding box 'hashicorp/bionic64' (v1.0.282) for provider: virtualbox
default: Downloading: https://vagrantcloud.com/hashicorp/boxes/bionic64/versions/1.0.282/providers/virtualbox.box
default:
==> default: Successfully added box 'hashicorp/bionic64' (v1.0.282) for 'virtualbox'!
==> default: Importing base box 'hashicorp/bionic64'...
==> default: Matching MAC address for NAT networking...
==> default: Checking if box 'hashicorp/bionic64' version '1.0.282' is up to date...
==> default: Setting the name of the VM: Vagrant_VM_Setup_default_1658134731918_88844
==> default: Clearing any previously set network interfaces...
==> default: Preparing network interfaces based on configuration...
default: Adapter 1: nat
==> default: Forwarding ports...
default: 22 (guest) => 2222 (host) (adapter 1)
==> default: Booting VM...
==> default: Waiting for machine to boot. This may take a few minutes...
default: SSH address: 127.0.0.1:2222
default: SSH username: vagrant
default: SSH auth method: private key
default:
default: Vagrant insecure key detected. Vagrant will automatically replace
default: this with a newly generated keypair for better security.
default:
default: Inserting generated public key within guest...
default: Removing insecure key from the guest if it's present...
default: Key inserted! Disconnecting and reconnecting using new SSH key...
==> default: Machine booted and ready!
==> default: Checking for guest additions in VM...
default: The guest additions on this VM do not match the installed version of
default: VirtualBox! In most cases this is fine, but in rare cases it can
default: prevent things such as shared folders from working properly. If you see
default: shared folder errors, please make sure the guest additions within the
default: virtual machine match the version of VirtualBox you have installed on
default: your host and reload your VM.
default:
default: Guest Additions Version: 6.0.10
default: VirtualBox Version: 6.1
==> default: Mounting shared folders...
default: /vagrant => C:/Vagrant_VM_Setup
Damit steht eine minimale VM mit den folgenden Release-Eigenschaften zur Verfügung:
vagrant@vagrant:~$ cat /etc/os-release
NAME="Ubuntu"
VERSION="18.04.3 LTS (Bionic Beaver)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 18.04.3 LTS"
VERSION_ID="18.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=bionic
UBUNTU_CODENAME=bionic
Sieht man sich die eingerichteten Filesysteme an, so fällt der Mountpoint /vagrant auf. Dieser erlaubt den Datenaustausch zwischen dem Host-Betriebssystem und der VM und enthält insbesondere die Vagrantfile-Datei und die von Vagrant verwendeten Metadaten zum Aufbau der virtuellen Maschine.
Beispiel 2: Einrichten zweier VMs mit Oracle Datenbanken als DataGuard Konfiguration
Nach dem ersten, sehr einfach gehaltenen Beispiel, hier nun ein Beispiel, das schon sehr nahe an eine reale Aufgabe herankommt:
Ausgangspunkt ist ein von Tim Hall bereitgestelltes Beispiel zur DataGuard Konfiguration, das an einigen Stellen modifiziert wurde. Tim ist DBA, Entwickler, Autor, Trainer und Oracle Ace Director und veröffentlicht im Internet sehr viele Oracle-spezifische Informationen. Für dieses Beispiel haben wir eine öffentliche Box mit dem Namen „madafa/CentOS7-x86_64“ in der HashiCorp Cloud bereitgestellt.
DataGuard ist eine Hochverfügbarkeitslösung von Oracle, in der eine Datenbank auf einem Server im „normalen“ Arbeitsmodus betrieben wird („Primary-DB“). Für den Fall eines Ausfalls wird mindestens eine weitere Datenbank bereitgestellt, die im Standby-Modus betrieben wird („Standby-DB“). Diese empfängt die Transaktionsinformationen der Primary-DB und wendet sie an, sodass ihr Datenbestand identisch zu dem der Primary-DB ist. Die Standby-DB ist im Normalfall nur im Mount-Status geöffnet. Je nach Situation können die Rolle von Primary- und Standby-DB mittels Switchover getauscht oder die Standby-DB ohne Berücksichtigung der ursprünglichen Primary-DB als neue Primary-DB aktiviert werden.
Benutzer
In der bereitgestellten Box ist neben den beiden obligatorischen Usern root und vagrant auch der User oracle eingerichtet. Dem User oracle sind die üblicherweise verwendeten Benutzergruppen oracle, dba und oinstall zugeordnet.
Vagrant User und Datensicherheit
Der vagrant User ist der User, mit dem sich Vagrant an der VM anmeldet und mit dem die im Rahmen des VM Setup erforderlichen Befehle ausgeführt werden. Dementsprechend hat dieser Benutzer über sudo die Möglichkeit, auch hochprivilegierte Befehle auszuführen oder sich alternativ mit dem root-User zu verbinden. Ursprünglich gab es die Konvention, dass der Betriebssystem-User vagrant das Passwort vagrant erhielt. Damit konnte man dann also beispielsweise eine Putty Session mit dem Benutzernamen vagrant und dem Passwort vagrant aufbauen. Diese Konvention birgt natürlich ein hohes Maß an Gefährdung für die Daten in der VM. Neuere Vagrant Versionen verwenden deshalb ein Paar von privatem und öffentlichem Schlüssel, mit denen über das Kommando vagrant ssh eine verschlüsselte Verbindung aufgenommen und anschließend sofort ein Austausch des Schlüssels vorgenommen wird. An dieser Stelle kann es in einigen Fällen zu Problemen kommen, nämlich dann, wenn der öffentliche Schlüssel nicht in der Datei authorized_keys im .ssh-Verzeichnis des Users vagrant bereitgestellt wurde. Dies ist insbesondere bei Boxes der Fall, die noch mit der ursprünglichen Anmeldung, also vagrant mit dem Passwort vagrant, konfiguriert und nicht mehr gepflegt wurden. Zu diesem Problem existieren viele unbeantwortete Anfragen im Internet. An dieser Stelle kann die folgende Information helfen: Wird eine Box heruntergeladen und hieraus eine VM erstellt, so baut Vagrant unter dem Gast-Betriebssystem Windows eine Verbindung mit einem privaten Schlüssel auf, der sich in der Datei C:\Users\.vagrant.d befindet. Dieser ist zwar nicht sicher, da er ja überall verfügbar ist, aber sobald Vagrant sich mit diesem Schlüssel verbinden kann, erfolgt automatisch ein Austausch durch ein neu generiertes Schlüsselpaar.
Vagrant Verzeichnisstruktur
Die eingesetzten Skripte sind in verschiedenen Verzeichnissen abgelegt:
- Basisverzeichnis: Dies ist ein beliebiges Verzeichnis im Windows Filesystem und dient als Startort des DataGuard Aufbaus über Vagrant.
- software: In diesem Verzeichnis wird die zuvor heruntergeladene Oracle Installationssoftware abgelegt, in diesem Fall LINUX.X64_193000_db_home.zip
- config: In diesem Verzeichnis befinden sich zwei Konfigurationsdateien
-
- vagrant.yml wird als Konfigurationsdatei (Include-File) für Vagrant verwendet. Hierin werden u.a. festgelegt, welche Box für die VM verwendet wird und mit welchen Basisparametern (Box, Plattentyp non_rotational, zwei Knoten, Name der VM, Anzahl der CPUs, Public IP-Adresse, Name der virtuellen Platte für die Oracle Installation im Windows Filesystem)
- install.env eine Datei, in der alle für den Aufbau und die Konfiguration der VM benötigten Linux Umgebungsvariablen definiert sind. Insbesondere werden diese Variablen für die Installation und Konfiguration der Oracle Software verwendet.
- node1: Verzeichnis mit einem Vagrantfile für Knoten 1 und einem Unterverzeichnis „scripts“ mit Linux-Scripten für die Einrichtung dieses Knotens
- node2: Analog node1
- shared_scripts: Linux-Scripte die für beide Knoten verwendet werden. Diese betreffen OS-spezifische Konfigurationen der beiden VMs
Detaillierte Beschreibung der einzelnen Dateien
In diesem Kapitel werden die Dateien, die zum Aufbau der beiden VMs für die DataGuard Installation verwendet wurden im Detail beschrieben: Jedes Unterkapitel zu der angegebenen Datei in dem angegeben Ordner beschreibt kurz die Aufgabe der entsprechenden Datei und listet diese anschließend auf. Eine Ausnahme für die Listings bildet natürlich die Oracle Software LINUX.X64_193000_db_home.zip
LINUX.X64_193000_db_home.zip im Verzeichnis software
Im software Verzeichnis wird die zuvor heruntergeladene komprimierte Oracle Installationsdatei abgelegt. Dieses Verzeichnis wird im Verlauf der Installation der VM in diese eingebunden, sodass beim Aufbau der VM darauf zugegriffen werden kann.
vagrant.yml im Verzeichnis config
In dieser Datei sind einige Basisparameter der VMs konfiguriert, nämlich
- Name und Version der zu verwendenden (herunterzuladenden) Box
- Name der VM in der Virtualisierungsumgebung
- Größe des Hauptspeichers
- Anzahl der zu verwendenden CPUs
- IP-Adresse
- Pfad für die Platte auf der die Oracle Dateien abgelegt werden
shared:
box: madafa/CentOS7-x86_64
box_version: 1.0.0
non_rotational: 'on'
node1:
vm_name: madafa_dg1
mem_size: 6144
cpus: 2
public_ip: 192.168.56.101
u01_disk: ./madafa_dg1_u01.vdi
node2:
vm_name: madafa_dg2
mem_size: 6144
cpus: 2
public_ip: 192.168.56.102
u01_disk: ./madafa_dg2_u01.vdi
install.env im Verzeichnis config
In dieser Datei sind alle im Rahmen des VM-Setup verwendeten / benötigten Umgebungsvariablen abgelegt. Hierzu gehören auch Umgebungsvariablen die dazu dienen, verschiedene Passwörter einzurichten. Der Benutzer der dieses Beispiel zur Einrichtung einer eigenen DataGuard Konfiguration verwenden möchte, sollte hier also auf jeden Fall die Passwörter austauschen.
export DOMAIN_NAME=MAINZ
export NODE1_HOSTNAME=madafa-dg-srv1
export NODE2_HOSTNAME=madafa-dg-srv2
export NODE1_FQ_HOSTNAME=${NODE1_HOSTNAME}.${DOMAIN_NAME}
export NODE2_FQ_HOSTNAME=${NODE2_HOSTNAME}.${DOMAIN_NAME}
export NODE1_PUBLIC_IP=192.168.56.101
export NODE2_PUBLIC_IP=192.168.56.102
export ORACLE_BASE=/u01/app/oracle # Basisverzeichnis für die Oracle-Installation
export ORA_INVENTORY=/u01/app/oraInventory # Zielverzeichnis für das Oracle Inventory
export ORACLE_HOME_EXT=product/19.0.0/dbhome_1 # Home-Verzeichnis der Installation relativ zu $ORACLE_BASE
export ORACLE_SID=MADAFA # SID der Primary und der Standby DB
export DB_NAME=${ORACLE_SID}
export PDB_NAME=pdb1 # Name der PDB
export NODE1_DB_UNIQUE_NAME=${ORACLE_SID}_SITE1 #
export NODE2_DB_UNIQUE_NAME=${ORACLE_SID}_SITE2 #
export DB_DOMAIN_STR=".${DOMAIN_NAME}"
export ORACLE_TERM=xterm
export ORA_LANGUAGES=en,en_GB
export NATIVE_NETWORK_ENCRYPTION=false
export DATA_DIR=/u01/oradata
# Passwörter > 8 Zeichen, Großbuchstabe, Ziffer, Sonderzeichen,
# keine Bestandteile mit dem User-Namen.
export ROOT_PASSWORD=Xr1_pks1N_rqPzDRgZLV
export ORACLE_PASSWORD=Xr1_pks2N_rqPzDRgZLV
export SYS_PASSWORD="Xr1_pks3N_rqPzDRgZLV"
export PDB_PASSWORD="Xr1_pks4N_rqPzDRgZLV"
export SYSDG_PASSWORD="Xr1_pks5N_rqPzDRgZLV"
export DB_SOFTWARE=LINUX.X64_193000_db_home.zip
Vagrantfile im Verzeichnis node1
Dieses Vagrantfile dient zur Einrichtung des ersten Knotens der DataGuard Konfiguration. Hier wird ebenfalls die bereits aus dem Vagrantfile für Knoten 1 bekannten yaml-Datei Umgebungsvariablen eingebunden und baut damit die VM für Knoten 2 auf. Die Datei ähnelt damit größtenteils der für Knoten 1. Unterschiede existieren nur, wo VM-spezifische Parameter gesetzt werden, wie z.B. bei der IP Adresse.
require 'yaml'
# Initialisierung von Variablen mit Werten der yaml-Datei im config Verzeichnis
params = YAML.load_file '../config/vagrant.yml'
var_box = params['shared']['box']
var_non_rotational = params['shared']['non_rotational']
var_vm_name = params['node2']['vm_name']
var_mem_size = params['node2']['mem_size']
var_cpus = params['node2']['cpus']
var_public_ip = params['node2']['public_ip']
var_u01_disk = params['node2']['u01_disk']
Vagrant.configure("2") do |config|
# Spezifikation des Box-Objektes, Belegung mit den Parametern des Objektes var_box
config.vm.box = var_box
# Forwarded port mapping für den Zugriff auf die Ports 1521 (Oracle Listener) und 5500 (OEM Express)
config.vm.network "forwarded_port", guest: 1521, host: 1522
config.vm.network "forwarded_port", guest: 5500, host: 5502
# Private IP-Adresse für den host only Zugang
config.vm.network "private_network", ip: var_public_ip
# Mapping von VM-Verzeichnissen auf Windows Verzeichnisse
# über die angegebenen Verzeichnisse ist ein Austausch von Dateien
# zwischen Windows und Linux möglich. Insbesondere dient das Mapping
# dazu, dass die VM auf die Konfiguirations- und Installationsfiles
# zugreifen kann.
# Beispielsweise wird das Windows config-Verzeichnis hierdurch in der VM als /vagrant_config
# bereitgestellt.
config.vm.synced_folder "../config", "/vagrant_config"
config.vm.synced_folder "../shared_scripts", "/vagrant_scripts"
config.vm.synced_folder "../software", "/vagrant_software"
# Belegung von VM Parametern mit Werten aus der oben inkludierten yaml-Datei
#
config.vm.provider "virtualbox" do |vb|
vb.memory = var_mem_size
vb.cpus = var_cpus
vb.name = var_vm_name
vb.customize ['storageattach', :id, '--storagectl', 'SATA Controller', '--port', '0', '--nonrotational', var_non_rotational]
unless File.exist?(var_u01_disk)
vb.customize ['createhd', '--filename', var_u01_disk, '--size', 100 * 1024]
end
vb.customize ['storageattach', :id, '--storagectl', 'SATA Controller', '--port', 1, '--device', 0, '--type', 'hdd', '--medium', var_u01_disk, '--nonrotational', var_non_rotational]
end
#
# Hier erfolgt der Aufruf für das Shell-Script zur Installation
config.vm.provision "shell", inline: <<-SHELL
sh /vagrant/scripts/setup.sh
SHELL
end
setup.sh im Verzeichnis node1/scripts und node2/scripts
Diese Datei besteht lediglich aus dem Aufruf der Datei root_setup.sh über sudo.
sudo bash -c 'sh /vagrant/scripts/root_setup.sh'
root_setup.sh im Verzeichnis node1/scripts und node2/scripts
. /vagrant_config/install.env
sh /vagrant_scripts/prepare_u01_disk.sh
sh /vagrant_scripts/install_os_packages.sh
echo "******************************************************************************"
echo " Einrichten der Passwörter für root und oracle entsprechend Umgebungsdatei "
echo " install.env und ändern der Zugriffsrechte für /u01." `date` "
echo "******************************************************************************"
echo -e "${ROOT_PASSWORD}\n${ROOT_PASSWORD}" | passwd
echo -e "${ORACLE_PASSWORD}\n${ORACLE_PASSWORD}" | passwd oracle
chown -R oracle:oinstall /u01
chmod -R 775 /u01
sh /vagrant_scripts/configure_hosts_base.sh
sh /vagrant_scripts/configure_chrony.sh
su - oracle -c 'sh /vagrant/scripts/oracle_user_environment_setup.sh'
. /home/oracle/scripts/setEnv.sh
sh /vagrant_scripts/configure_hostname.sh
echo "******************************************************************************"
echo " Freischalten der Firewall für Port 1521." `date`
echo "******************************************************************************"
/usr/bin/firewall-cmd --zone=public --add-port=1521/tcp --permanent
/usr/bin/firewall-cmd --reload
# Installation der Oracle Software
su - oracle -c 'sh /vagrant_scripts/oracle_db_software_installation.sh'
echo "******************************************************************************"
echo "Run DB root scripts." `date`
echo "******************************************************************************"
sh ${ORA_INVENTORY}/orainstRoot.sh
sh ${ORACLE_HOME}/root.sh
# Anlegen einer Datenbank
su - oracle -c 'sh /vagrant/scripts/oracle_create_database.sh'
oracle_user_environment_setup.sh im Verzeichnis node1/scripts und node2/scripts
Diese Datei legt die Umgebung des Users oracle fest. Dazu gehören
- Anlegen eines Skript-Verzeichnis im Home-Verzeichnis des Users oracle
- Definition von Umgebungsvariablen für den User oracle
- Anlegen einer Profile-Datei für die Bash
- Anlegen der Verzeichnisse für das ORACLE_HOME und die Oracle Datendateien
. /vagrant_config/install.env
echo "******************************************************************************"
echo "Create environment scripts." `date`
echo "******************************************************************************"
mkdir -p /home/oracle/scripts
cat > /home/oracle/scripts/setEnv.sh <# Oracle Settings
export TMP=/tmp
export TMPDIR=\$TMP
export ORACLE_HOSTNAME=${NODE2_FQ_HOSTNAME}
export ORACLE_BASE=${ORACLE_BASE}
export ORA_INVENTORY=${ORA_INVENTORY}
export ORACLE_HOME=$ORACLE_BASE/${ORACLE_HOME_EXT}
export ORACLE_SID=${ORACLE_SID}
export DATA_DIR=${DATA_DIR}
export ORACLE_TERM=xterm
export BASE_PATH=/usr/sbin:\$PATH
export PATH=\$ORACLE_HOME/bin:\$BASE_PATH
export LD_LIBRARY_PATH=\$ORACLE_HOME/lib:/lib:/usr/lib
export CLASSPATH=\$ORACLE_HOME/JRE:\$ORACLE_HOME/jlib:\$ORACLE_HOME/rdbms/jlib
EOF
cat >> /home/oracle/.bash_profile <. /home/oracle/scripts/setEnv.sh
EOF
echo "******************************************************************************"
echo "Create directories." `date`
echo "******************************************************************************"
. /home/oracle/scripts/setEnv.sh
mkdir -p ${ORACLE_HOME}
mkdir -p ${DATA_DIR}
oracle_create_database.sh im Verzeichnis node1/scripts
Diese Datei richtet die Datenbank ein und besteht aus folgenden Aktionen:
- Anlegen der TNS-Dateien listener.ora, tnsnames.ora, sqlnet.ora
- Starten des Listeners
- Eigentliches Anlegen der Datenbank über einen parametrisierten dbca (database creation assistant) Aufruf mit der silent-Option
- Einrichten von Forced Logging für den DataGuard Betrieb
- Einrichten der Standby Redolog Dateien
- Einschalten der Flashback Eigenschaft
. /vagrant_config/install.env
echo "******************************************************************************"
echo " Konfiguration der Oracle TNS Dateien" `date`
echo "******************************************************************************"
cat > ${ORACLE_HOME}/network/admin/tnsnames.ora <LISTENER${DB_DOMAIN_STR} = (ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE1_FQ_HOSTNAME})(PORT = 1521))
${NODE1_DB_UNIQUE_NAME}${DB_DOMAIN_STR} =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE1_FQ_HOSTNAME})(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SID = ${ORACLE_SID})
)
)
${NODE2_DB_UNIQUE_NAME}${DB_DOMAIN_STR} =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE2_FQ_HOSTNAME})(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SID = ${ORACLE_SID})
)
)
EOF
cat > ${ORACLE_HOME}/network/admin/listener.ora <LISTENER =
(DESCRIPTION_LIST =
(DESCRIPTION =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE1_FQ_HOSTNAME})(PORT = 1521))
(ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))
)
)
SID_LIST_LISTENER =
(SID_LIST =
(SID_DESC =
(GLOBAL_DBNAME = ${NODE1_DB_UNIQUE_NAME})
(SID_NAME = ${ORACLE_SID})
(ORACLE_HOME = ${ORACLE_HOME})
)
(SID_DESC =
(GLOBAL_DBNAME = ${NODE1_DB_UNIQUE_NAME}${DB_DOMAIN_STR})
(SID_NAME = ${ORACLE_SID})
(ORACLE_HOME = ${ORACLE_HOME})
)
(SID_DESC =
(SID_NAME = ${ORACLE_SID})
(GLOBAL_DBNAME = ${NODE1_DB_UNIQUE_NAME}_DGMGRL${DB_DOMAIN_STR})
(ORACLE_HOME = ${ORACLE_HOME})
(ENVS="TNS_ADMIN=${ORACLE_HOME}/network/admin")
)
)
ADR_BASE_LISTENER = ${ORACLE_BASE}
INBOUND_CONNECT_TIMEOUT_LISTENER=400
EOF
cat > ${ORACLE_HOME}/network/admin/sqlnet.ora <SQLNET.INBOUND_CONNECT_TIMEOUT=400
NAMES.DEFAULT_DOMAIN=${DOMAIN_NAME}
EOF
if [ "${NATIVE_NETWORK_ENCRYPTION}" = "true" ]; then
cat >> ${ORACLE_HOME}/network/admin/sqlnet.ora <SQLNET.ENCRYPTION_SERVER=REQUIRED
SQLNET.ENCRYPTION_TYPES_SERVER=(AES256)
SQLNET.ENCRYPTION_CLIENT=REQUIRED
SQLNET.ENCRYPTION_TYPES_CLIENT=(AES256)
SQLNET.CRYPTO_CHECKSUM_SERVER=REQUIRED
SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER = (SHA256)
SQLNET.CRYPTO_CHECKSUM_CLIENT=REQUIRED
SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT = (SHA256)
EOF
fi
if [ "${DB_DOMAIN}" != "" ]; then
cat >> ${ORACLE_HOME}/network/admin/sqlnet.ora <NAMES.DEFAULT_DOMAIN=${DB_DOMAIN}
EOF
fi
echo "******************************************************************************"
echo " Start listener." `date`
echo "******************************************************************************"
lsnrctl stop
lsnrctl start
lsnrctl status
echo "******************************************************************************"
echo " Anlegen der DB" `date`
echo "******************************************************************************"
dbca -silent -createDatabase \
-templateName General_Purpose.dbc \
-sid ${ORACLE_SID} \
-responseFile NO_VALUE \
-gdbname ${DB_NAME}${DB_DOMAIN_STR} \
-characterSet AL32UTF8 \
-sysPassword ${SYS_PASSWORD} \
-systemPassword ${SYS_PASSWORD} \
-createAsContainerDatabase true \
-numberOfPDBs 1 \
-pdbName ${PDB_NAME} \
-pdbAdminPassword ${PDB_PASSWORD} \
-databaseType MULTIPURPOSE \
-automaticMemoryManagement false \
-totalMemory 2048 \
-storageType FS \
-datafileDestination "${DATA_DIR}" \
-redoLogFileSize 50 \
-emConfiguration NONE \
-initparams db_name=${DB_NAME},db_unique_name=${NODE1_DB_UNIQUE_NAME} \
-ignorePreReqs
echo "******************************************************************************"
echo " PDB auf auto-start setzen" `date`
echo "******************************************************************************"
sqlplus / as sysdba <ALTER SYSTEM SET db_create_file_dest='${DATA_DIR}';
ALTER SYSTEM SET db_create_online_log_dest_1='${DATA_DIR}';
ALTER PLUGGABLE DATABASE ${PDB_NAME} SAVE STATE;
ALTER SYSTEM RESET local_listener;
exit;
EOF
echo "******************************************************************************"
echo " Konfiguration von Archivelog Mode, Standby Logs and Flashback." `date`
echo "******************************************************************************"
mkdir -p ${ORACLE_BASE}/fast_recovery_area
sqlplus / as sysdba <
-- Set recovery destination.
alter system set db_recovery_file_dest_size=20G;
alter system set db_recovery_file_dest='${ORACLE_BASE}/fast_recovery_area';
-- Archiving archivieren
SHUTDOWN IMMEDIATE;
STARTUP MOUNT;
ALTER DATABASE ARCHIVELOG;
ALTER DATABASE OPEN;
ALTER DATABASE FORCE LOGGING;
ALTER SYSTEM SWITCH LOGFILE;
-- Standby Redolog Dateien anlegen
ALTER DATABASE ADD STANDBY LOGFILE THREAD 1 GROUP 10 SIZE 50M;
ALTER DATABASE ADD STANDBY LOGFILE THREAD 1 GROUP 11 SIZE 50M;
ALTER DATABASE ADD STANDBY LOGFILE THREAD 1 GROUP 12 SIZE 50M;
ALTER DATABASE ADD STANDBY LOGFILE THREAD 1 GROUP 13 SIZE 50M;
-- Falls keine Oracle Managed Files verwendet werden sollen, müssen hier Pfad und Dateiname spezifiziert werden.
--ALTER DATABASE ADD STANDBY LOGFILE THREAD 1 GROUP 10 ('${DATA_DIR}/${ORACLE_SID^^}/standby_redo01.log') SIZE 50M;
-- Aktivieren von Flashback Database.
ALTER DATABASE FLASHBACK ON;
ALTER SYSTEM SET STANDBY_FILE_MANAGEMENT=AUTO;
EXIT;
EOF
-- Den DataGuard User entsperren, Berechtigung erteilen und das Passwort setzen
ALTER USER SYSDG ACCOUNT UNLOCK;
GRANT SYSDG TO SYSDG;
ALTER USER SYSDG IDENTIFIED by ${SYSDG_PASSWORD};
echo "******************************************************************************"
echo " Aktivieren des DataGuard Brokers." `date`
echo "******************************************************************************"
sqlplus / as sysdba <
ALTER SYSTEM SET dg_broker_start=TRUE;
EXIT;
EOF
oracle_create_database.sh im Verzeichnis node2/scripts
Diese Datei richtet die Datenbank auf Knoten 2 ein. Sie unterscheidet sich im Wesentlichen von der gleichnamigen Datei für Knoten 1 dadurch, dass die Datenbank hier nicht durch einen dbca Aufruf, sondern durch rman (Recovery Manager) aus der primären Datenbank dupliziert wird. Folgende Aktionen werden durchgeführt:
- Anlegen der TNS-Dateien listener.ora, tnsnames.ora, sqlnet.ora
- Anlegen eines Eintrags in der Datei /etc/oratab
- Starten des Listeners
- Starten der für den Betrieb einer Datenbank erforderlichen Basisprozesse mit Hilfe einer rudimentären init.ora Datei (startup nomount)
- Duplizieren der Primärdatenbank auf Knoten 1 zu einer Standby-Datenbank auf Knoten 2 über „rman duplicate“
- Abschließend wird der DataGuard Broker eingerichtet. Diese Aktion erfolgt hier zwar mit einer Datenbank-Verbindung auf Knoten 1, wirkt sich aber implizit auch auf die Datenbank auf Knoten 2 aus.
. /vagrant_config/install.env
echo "******************************************************************************"
echo " Konfiguration der Oracle TNS Dateien" `date`
echo "******************************************************************************"
cat > ${ORACLE_HOME}/network/admin/tnsnames.ora <LISTENER${DB_DOMAIN_STR} = (ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE2_FQ_HOSTNAME})(PORT = 1521))
${NODE1_DB_UNIQUE_NAME}${DB_DOMAIN_STR} =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE1_FQ_HOSTNAME})(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SID = ${ORACLE_SID})
)
)
${NODE2_DB_UNIQUE_NAME}${DB_DOMAIN_STR} =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE2_FQ_HOSTNAME})(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SID = ${ORACLE_SID})
)
)
EOF
cat > ${ORACLE_HOME}/network/admin/listener.ora <LISTENER =
(DESCRIPTION_LIST =
(DESCRIPTION =
(ADDRESS = (PROTOCOL = TCP)(HOST = ${NODE2_FQ_HOSTNAME})(PORT = 1521))
(ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))
)
)
SID_LIST_LISTENER =
(SID_LIST =
(SID_DESC =
(GLOBAL_DBNAME = ${NODE2_DB_UNIQUE_NAME})
(SID_NAME = ${ORACLE_SID})
(ORACLE_HOME = ${ORACLE_HOME})
)
(SID_DESC =
(GLOBAL_DBNAME = ${NODE2_DB_UNIQUE_NAME}${DB_DOMAIN_STR})
(SID_NAME = ${ORACLE_SID})
(ORACLE_HOME = ${ORACLE_HOME})
)
(SID_DESC =
(SID_NAME = ${ORACLE_SID})
(GLOBAL_DBNAME = ${NODE2_DB_UNIQUE_NAME}_DGMGRL${DB_DOMAIN_STR})
(ORACLE_HOME = ${ORACLE_HOME})
(ENVS="TNS_ADMIN=${ORACLE_HOME}/network/admin")
)
)
ADR_BASE_LISTENER = ${ORACLE_BASE}
INBOUND_CONNECT_TIMEOUT_LISTENER=400
EOF
cat > ${ORACLE_HOME}/network/admin/sqlnet.ora <SQLNET.INBOUND_CONNECT_TIMEOUT=400
EOF
if [ "${NATIVE_NETWORK_ENCRYPTION}" = "true" ]; then
cat >> ${ORACLE_HOME}/network/admin/sqlnet.ora <SQLNET.ENCRYPTION_SERVER=REQUIRED
SQLNET.ENCRYPTION_TYPES_SERVER=(AES256)
SQLNET.ENCRYPTION_CLIENT=REQUIRED
SQLNET.ENCRYPTION_TYPES_CLIENT=(AES256)
SQLNET.CRYPTO_CHECKSUM_SERVER=REQUIRED
SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER = (SHA256)
SQLNET.CRYPTO_CHECKSUM_CLIENT=REQUIRED
SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT = (SHA256)
EOF
fi
if [ "${DB_DOMAIN}" != "" ]; then
cat >> ${ORACLE_HOME}/network/admin/sqlnet.ora <NAMES.DEFAULT_DOMAIN=${DB_DOMAIN}
EOF
fi
cat >> /etc/oratab << EOF
MADAFA:/u01/app/oracle/product/19.0.0/dbhome_1:N
EOF
echo "******************************************************************************"
echo " Start listener." `date`
echo "******************************************************************************"
lsnrctl stop
lsnrctl start
lsnrctl status
echo "******************************************************************************"
echo " Anlegen von Verzeichnissen, Passwordfile und temporärer init.ora Datei." `date`
echo "******************************************************************************"
mkdir -p /u01/oradata/${NODE2_DB_UNIQUE_NAME^^}/pdbseed
mkdir -p /u01/oradata/${NODE2_DB_UNIQUE_NAME^^}/pdb1
mkdir -p ${ORACLE_BASE}/fast_recovery_area/${NODE2_DB_UNIQUE_NAME^^}
mkdir -p ${ORACLE_BASE}/admin/${NODE2_DB_UNIQUE_NAME}/adump
orapwd file=$ORACLE_HOME/dbs/orapw${ORACLE_SID} password=${SYS_PASSWORD} entries=10
cat > /tmp/init${ORACLE_SID}_stby.ora <*.db_name='${ORACLE_SID}'
*.db_unique_name='${NODE2_DB_UNIQUE_NAME^^}'
EOF
echo "******************************************************************************"
echo " Starten der Basisprozesse für eine Oracle Datenbank." `date`
echo "******************************************************************************"
sqlplus / as sysdba <STARTUP NOMOUNT PFILE='/tmp/init${ORACLE_SID}_stby.ora';
exit;
EOF
echo "******************************************************************************"
echo " Anlegen der Standby Datenbank" `date`
echo "******************************************************************************"
rman TARGET sys/${SYS_PASSWORD}@${NODE1_DB_UNIQUE_NAME}${DB_DOMAIN_STR} AUXILIARY sys/${SYS_PASSWORD}@${NODE2_DB_UNIQUE_NAME}${DB_DOMAIN_STR} <
DUPLICATE TARGET DATABASE
FOR STANDBY
FROM ACTIVE DATABASE
DORECOVER
SPFILE
SET db_unique_name='${NODE2_DB_UNIQUE_NAME}'
SET audit_file_dest='${ORACLE_BASE}/admin/${NODE2_DB_UNIQUE_NAME}/adump'
NOFILENAMECHECK;
exit;
EOF
echo "******************************************************************************"
echo " Aktivieren des DataGuard Brokers" `date`
echo "******************************************************************************"
sqlplus / as sysdba <
ALTER SYSTEM SET dg_broker_start=true;
EXIT;
EOF
echo "**********************************************************************************"
echo " Konfigurieren des DataGuard Brokers (auf Knoten 1) und Anzeige der Konfiguration." `date`
echo "**********************************************************************************"
dgmgrl sys/${SYS_PASSWORD}@${NODE1_DB_UNIQUE_NAME} <REMOVE CONFIGURATION;
CREATE CONFIGURATION madafa_dg_config AS PRIMARY DATABASE IS ${NODE1_DB_UNIQUE_NAME} CONNECT IDENTIFIER IS ${NODE1_DB_UNIQUE_NAME}${DB_DOMAIN_STR};
ADD DATABASE ${NODE2_DB_UNIQUE_NAME} AS CONNECT IDENTIFIER IS ${NODE2_DB_UNIQUE_NAME}${DB_DOMAIN_STR} MAINTAINED AS PHYSICAL;
ENABLE CONFIGURATION;
SHOW CONFIGURATION;
SHOW DATABASE ${NODE1_DB_UNIQUE_NAME};
SHOW DATABASE ${NODE2_DB_UNIQUE_NAME};
EXIT;
EOF
echo "******************************************************************************"
echo " Überprüfung der Konfiguration." `date`
echo "******************************************************************************"
echo " Kurze Pause"
echo " Die Konfiguration benötigt eine kurze Synchronisationsphase"
echo " zwischen Primär- und Standby-DB"
sleep 60
dgmgrl sys/${SYS_PASSWORD}@${NODE1_DB_UNIQUE_NAME} <VALIDATE DATABASE ${NODE1_DB_UNIQUE_NAME};
VALIDATE DATABASE ${NODE2_DB_UNIQUE_NAME};
VALIDATE DATABASE ${NODE2_DB_UNIQUE_NAME} SPFILE;
VALIDATE STATIC CONNECT IDENTIFIER FOR ${NODE1_DB_UNIQUE_NAME};
VALIDATE STATIC CONNECT IDENTIFIER FOR ${NODE2_DB_UNIQUE_NAME};
EXIT;
EOF
configure_chrony.sh im Verzeichnis shared_scripts
Mit diesem Script wird der NTP Daemon chrony aktiviert, gestartet und konfiguriert.
echo "******************************************************************************"
echo "Enable chronyd service." `date`
echo "******************************************************************************"
systemctl enable chronyd
systemctl restart chronyd
chronyc -a 'burst 4/4'
chronyc -a makestep
configure_hostname.sh im Verzeichnis shared_scripts
Mit diesem Script wird die Datei /etc/hostname angelegt und der Hostname entsprechend der Variablen $ORACLE_HOSTNAME eingetragen. Diese Variable enthält den voll qualifizierten Namen der jeweiligen VM aus der VM-spezifischen Datei oracle_user_environment_setup.sh, die diesen aus der Variablen $NODE1_FQ_HOSTNAME der Datei install.env im Verzeichnis config erhält.
echo "******************************************************************************"
echo " Setzen des Host-Namens." `date`
echo "******************************************************************************"
hostname ${ORACLE_HOSTNAME}
cat > /etc/hostname <${ORACLE_HOSTNAME}
EOF
configure_hosts_base.sh im Verzeichnis shared_scripts
Mit diesem Script wird die Datei /etc/hosts um die Public IP Adresse, den Hostnamen und den voll qualifizierten Hostnamen erweitert. Die Werte der verwendeten Parameter $NODE1 bzw. $NODE2 stammen aus der Datei install.env des Verzeichnis config.
echo "******************************************************************************"
echo " Eintragen der Infos zu den beiden Knoten in die Datei /etc/hosts." `date`
echo "******************************************************************************"
cat >> /etc/hosts <# Public
${NODE1_PUBLIC_IP} ${NODE1_FQ_HOSTNAME} ${NODE1_HOSTNAME}
${NODE2_PUBLIC_IP} ${NODE2_FQ_HOSTNAME} ${NODE2_HOSTNAME}
EOF
install_os_packages.sh im Verzeichnis shared_scripts
Dieses Script konfiguriert den Google Nameserver, und lädt und installiert einige von Oracle verwendete Zusatzpakete (EPEL = „Extra Packages for Enterprise Linux“).
echo "******************************************************************************"
echo " Einrichten des YUM Repository und Installation der Basispakete." `date`
echo "******************************************************************************"
echo "nameserver 8.8.8.8" >> /etc/resolv.conf
yum install -y yum-utils
yum install -y oracle-epel-release-el7
yum-config-manager --enable ol7_developer_EPEL
yum install -y zip unzip # sshpass
yum install -y oracle-database-preinstall-19c
yum -y update
oracle_db_software_installation.sh im Verzeichnis shared_scripts
Dieses Script entpackt die im Vorfeld (s.o.) heruntergeladene Oracle Software und installiert diese. Hinweis: Es wird in diesem Schritt noch keine Datenbank angelegt.
. /vagrant_config/install.env
echo "******************************************************************************"
echo " Entpacken der Oracle Software." `date`
echo "******************************************************************************"
cd ${ORACLE_HOME}
unzip -oq /vagrant_software/${DB_SOFTWARE}
echo "******************************************************************************"
echo " Hier nur die Software installieren, keine DB konfigurieren." `date`
echo "******************************************************************************"
${ORACLE_HOME}/runInstaller -ignorePrereq -waitforcompletion -silent \
-responseFile ${ORACLE_HOME}/install/response/db_install.rsp \
oracle.install.option=INSTALL_DB_SWONLY \
ORACLE_HOSTNAME=${ORACLE_HOSTNAME} \
UNIX_GROUP_NAME=oinstall \
INVENTORY_LOCATION=${ORA_INVENTORY} \
SELECTED_LANGUAGES=${ORA_LANGUAGES} \
ORACLE_HOME=${ORACLE_HOME} \
ORACLE_BASE=${ORACLE_BASE} \
oracle.install.db.InstallEdition=EE \
oracle.install.db.OSDBA_GROUP=dba \
oracle.install.db.OSBACKUPDBA_GROUP=dba \
oracle.install.db.OSDGDBA_GROUP=dba \
oracle.install.db.OSKMDBA_GROUP=dba \
oracle.install.db.OSRACDBA_GROUP=dba \
SECURITY_UPDATES_VIA_MYORACLESUPPORT=false \
DECLINE_SECURITY_UPDATES=true
prepare_u01_disk.sh im Verzeichnis shared_scripts
Dieses Script legt eine neue Platte mit einem neuen Filesystem an und mountet diese unter /u01.
echo "******************************************************************************"
echo " Vorbereiten der Platte /u01." `date`
echo "******************************************************************************"
# Neue Partition für die gesamte Platte.
echo -e "n\np\n1\n\n\nw" | fdisk /dev/sdb
# Filesystem erstellen
mkfs.xfs -f /dev/sdb1
# Mount-Point anlegen, fstab erweitern und Mounten der Platte.
UUID=`blkid -o value /dev/sdb1 | grep -v xfs`
mkdir /u01
cat >> /etc/fstab <UUID=${UUID} /u01 xfs defaults 1 2
EOF
mount /u01
Von der VM zur Box
In diesem Abschnitt wird dargestellt, wie man ausgehend von einer virtuellen Maschine eine Box in die Vagrant Cloud bringt. Die Beschreibung bezieht sich auf eine VM in der Virtual Box.
Zunächst muss die Ausgangs-VM einige Bedingungen erfüllen, damit eine daraus resultierende Box von Vagrant verwendet werden kann. Diese sind:
- Der Benutzer vagrant muss existieren, das Passwort dieses Benutzers ist irrelevant, sollte aber natürlich alle Anforderungen an ein sicheres Passwort erfüllen
- Der Public Key zu dem Private Key der Vagrant Installation (Datei C:\Users\\vagrant.d\insecure_private_key) muss in die Datei ~vagrant/.ssh/authorized_keys aufgenommen worden sein. Hinweis hierzu: Der Public Key wird im Rahmen des VM-Aufbaus durch Vagrant ersetzt.
- In der Ausgangs-VM müssen die Guest Additions installiert sein.
- Das erste Netzwerk Interface der VM muss ein NAT Interface sein
Wenn diese Anforderungen erfüllt sind, wird die Ausgangs-VM heruntergefahren und mit folgendem Kommando ein Package erstellt:
vagrant package --base --output .box
In einem zweiten Schritt sollte der Hashwert der generierten Box-Datei ermittelt werden. Im folgenden Beispiel wurde das Verfahren SHA512 verwendet.
Get-FileHash -path .box -algorithm SHA512|fl
Jetzt kann die Box-Datei in die HashiCorp Cloud geladen werden. Die URL hierzu lautet Vagrant Cloud by HashiCorp . Nachdem man sich dort angemeldet hat, kann man über den Button New Vagrant Box Wizard geführt die Box-Datei hochladen. Nach dem Hochladen der Box nicht vergessen, den Release Version Button zu verwenden, um diese verfügbar zu machen.
Aufbau der DataGuard Knoten
Nachdem das Template einer VM als Box in die Vagrant Cloud geladen wurde, begibt man sich in das Verzeichnis node1 und führt dort den folgenden Befehl aus:
vagrant up
Dies lädt die entsprechende Box, erstellt damit eine VM und führt innerhalb der VM die Skripte aus, die erforderlich sind, um die Oracle Software auf Knoten 1 zu installieren und eine Datenbank anzulegen.
Anschließend begibt man sich in das Verzeichnis node2 und führt dort ebenfalls das o.a. Statement aus, das auch hier dazu führt, dass eine Basis-VM angelegt und mit den erforderlichen Skripten eingerichtet wird.
Zusammenfassung
Es wurde das Tool Vagrant vorgestellt mit der Templates von virtuellen Maschinen (Boxes) erstellt und genutzt werden können, um Instanzen dieser Templates anzulegen. Hierzu wurden zwei Beispiele präsentiert, wobei in Beispiel 2 gezeigt wurde, wie diese Instanzen im Rahmen des Aufbaus durch Vagrant skriptgesteuert erweitert werden können. Das Ergebnis des Beispiel 2 war eine komplett installierte und konfigurierte DataGuard Umgebung.
Möchten Sie mehr zum Thema Vagarant und dessen Möglichkeiten erfahren? Dann kontaktieren Sie uns gerne ganz einfach und unverbindlich über unser Kontaktformular und lassen sich von unseren Experten dazu umfassend beraten.
