Select Page

NETWAYS Blog

Orchestration-Automation in einem Rutsch

Gerade für Testzwecke ist es von Vorteil, wenn man z.B. in der Cloud virtuelle Maschinen (VM’s) ohne großen Aufwand installieren und verwalten kann. Nur kommt noch die Installation von Programmen und Tools dazu, um die Testumgebung fertig zu bekommen, damit Test-Szenarien abgebildet werden können. Tools wie Terraform, Ansible oder Puppet und Bolt kommen da meistens zum Einsatz. Aber wie wäre es, wenn zum Beispiel sein Terraform-Deployment Verzeichnis  mit den .tf files schon vorhanden ist und nur alles in einem Rutsch ausrollen möchte. Da ich mich mit puppet-bolt schon mal auseinander gesetzt hatte, suchte ich nach einer Lösung und wurde fündig, denn Bolt kann terraform apply  ausführen, puppet-agent darauf installieren und der anschließend ein Puppet Manifest ausrollen. In meinem Kurz-Beispiel wird eine Ubuntu  VM erzeugt, Apache2 installiert und eine Webseite erstellt.

Wie das funktioniert erkläre ich in diesem Post:
Voraussetzung:
Terraform, puppet-agent und puppet-bolt müssen installiert sein.

Ich habe mir ein Verzeichnis angelegt z.B. terraform_puppet und in diesem sind folgende Dateien abgelegt:

├── bolt-project.yaml
├── data
│   └── common.yaml
├── files
│   └── site.html
├── hiera.yaml
├── inventory.yaml
├── manifests
├── plans
│   └── init.pp

Wichtig von den Dateien ist die bolt-project.yaml, die inventory.yaml und die init.pp, deren Inhalt sieht folgendermaßen aus:

bolt-project.yaml
---
name: terraform_puppet
modulepath: ~/puppet/modules

inventory.yaml
---
groups:
- name: terraform
targets: []
config:
transport: ssh
ssh:
private-key: ~/.ssh/passwordlesskey/id_rsa
user: ubuntu
host-key-check: false

Die ganze Magie passiert aber in dem Skript init.pp

plan terraform_puppet(String $tf_path) {
$localhost = get_targets('localhost')

# Create infrastructure with terraform apply
run_command("cd ${tf_path} && terraform apply --auto-approve && sleep 20", $localhost)
$ip_string = run_command("cd ${$tf_path} && terraform output instance_ips",
$localhost).map |$r| { $r['stdout'] }
$ips = Array($ip_string).map |$ip| { $ip.strip }

# Turn IPs into Bolt targets, and add to inventory
$targets = $ips.map |$ip| {
Target.new("${$ip}").add_to_group('terraform')
}

# Deploy website
apply_prep($targets, _run_as => 'root', _required_modules => ['apache'])

apply($targets, _run_as => 'root') {
include apache
file { '/var/www/html/index.html':
ensure => 'file',
source => 'puppet:///modules/terraform_puppet/site.html',
}
}
return $ips
# Or diagnose issues across your terraform infrastructure
run_command('uptime', $targets)
}

Ich habe das ganz bei uns im Openstack umgesetzt, es kann aber auch in anderen Cloud Umgebungen übernommen werden und muss diesbezüglich angepasst werden.

So um das ganze jetzt in Gang zu setzen führt man folgendes Kommando in diesem terraform_puppet Verzeichnis aus:

bolt plan run terraform_puppet -i inventory.yaml tf_path=~/terraform/vmdir

Für alle die, die Puppet und Ruby Wissen haben, sollte das selbsterklärend sein, ansonsten grobe kurze Erklärung:

Bolt führt ein Skript aus das ein Terraform apply triggert und die IP als Variable speichert und als inventory Host-Target zu den groups hinzufügt,
damit diese als $target Variable vom Bolt inventory und dann per puppet apply genutzt werden kann. Das puppet Module Apache wird dazwischen auch mit eingelesen und genutzt.
Das schöne ist, die Funktion von bolt apply_prep, diese sorgt dafür, das für das per terraform installierte VM-OS der puppet-agent installiert und ausgeführt werden kann, wenn man das ganze laufen lässt sieht man es als command durchlaufen.
Anschließend wird per bolt apply ein puppet code  per puppet apply ausgeführt, der in unserem Fall den Apache2 installiert und einen index.html an die entsprechende Stelle kopiert (die man vorher unter files selber anlegen muss) und dann den Apache2 Service startet.

Das Ergebnis sollte dann die Webseite der index.html sein , wenn man die IP-Adresse der VM im Browser (http://$ipaddress_vm eingibt.

Das ist natürlich nur ein ganz vereinfachtes Beispiel, aber die Möglichkeiten die man damit hat, finde ich genial.

Natürlich bieten wir zum Thema Puppet auch Trainings an, wo man die Grundlagen der Automatisierung mit Puppet vermittelt bekommt.

Viel Spaß und Erfolg beim Ausprobieren.

Johannes Carraro
Johannes Carraro
Senior Systems Engineer

Bevor Johannes bei NETWAYS anheuerte war er knapp drei Jahre als Systemadministrator in Ansbach tätig. Seit Februar 2016 verstärkt er nun unser Team Operations als Senior Systems Engineer. In seiner Freizeit spielt Johannes E-Gitarre, bastelt an Linux Systemen zuhause herum und ertüchtigt sich beim Tischtennisspielen im Verein, bzw. Mountainbiken, Inlinern und nicht zuletzt Skifahren.

Cloud-Ressourcen effizient managen: Terraform Trainer Lennart in der aktuellen iX

Der heute erreichte Grad der Virtualisierung erlaubt es, nahezu ganze Rechenzentren und ihre Netzinfrastruktur virtuell abzubilden. Dazu bedarf es eines Infrastructure-as-Code-Werkzeugs wie Terraform, das sich dem Multicloud-Management verschrieben hat. Terraform stellt Rechenzentrumsressourcen unterschiedlicher Cloud-Provider bereit – bei Bedarf auch für andere Werkzeuge.

Wie das Ganze funktioniert, erklärt unser Terraform Trainer Lennart in der aktuellen iX Ausgabe. Wenn Dich das Thema interessiert und Du vor hast, mit Terraform zu arbeiten, dann solltest Du Dich unbedingt zu einer unserer Terraform Schulungen anmelden. Dein Trainer: Lennart Betz!

Wir haben die Terraform Schulung in drei Versionen im Programm, mit Fokus auf OpenStack, AWS oder Azure. Darum geht’s bei allen dreien: Mit der aktuellen Version von Terraform und seiner Konfigurationssprache HCL (Hashicorp Configuration Language) in Version 0.12 hat sich das Vorgehen zur Automatisierung von Cloud Infrastruktur weiterentwickelt. Unsere Terraform Schulung zeigt, wie Infrastruktur mit der Terraform eigenen DSL (HCL, Hashicorp Configuration Language) idempotent realisiert wird. Neben der Theorie mit vielen Beispielen beinhalten die Fortbildungen praktische Übungen anhand von OpenStack, AWS oder Azure. Ebenfalls erfolgt eine kurze Einführung in cloud-init, um weitere Software zu installieren und zu konfigurieren.

Die kommenden Terraform Schulungstermine

Melde Dich jetzt an und sichere Dir Deinen Platz!

Die genauen Inhalte, Voraussetzungen und alles weitere Wissenwerte erfährst Du auf unserer NETWAYS Trainings-Seite zur Terraform Schulung.

 

Terraform Training: Provisionierung von Infrastruktur in der Cloud

Mit dem Infrastructure-as-Code-Werkzeug (IaC) Terraform lässt sich Infrastruktur für Anwendungen in der Cloud automatisiert erstellen und verwalten. Das Tool abstrahiert die APIs unterschiedlicher Anbieter mit sogenannten Providern. So kann die Konfiguration Deiner Infrastruktur revisionssicher dokumentiert und von allen Teammitgliedern gemeinsam genutzt und bearbeitet werden.

Terraform nimmt Administrator*innen und Entwickler*innen viel Routinearbeit ab, erfordert aber eine gute Einarbeitung. Und hier kommen wir ins Spiel: In unserer Schulung lernst Du, wie Du mit Terraform Infrastrukturen sicher und nachvollziehbar erstellen, ändern und verbessern kannst.

Mit der aktuellen Version von Terraform und seiner Konfigurationssprache HCL (Hashicorp Configuration Language) in Version 0.12 hat sich das Vorgehen zur Automatisierung von Cloud-Infrastruktur weiterentwickelt.

Von HCL bis cloud-init

Unsere zweitägige Schulung beginnt mit einer Einführung in HCL. Anschließend zeigen wir Dir, wie Du Infrastruktur für AWS oder OpenStack wiederverwendbar und idempotent mit Terraform realisierst. Ebenfalls erfolgt eine Einführung in cloud-init, um weitere Software zu installieren und zu konfigurieren.

Folgende Linux-Kenntnisse sind Grundvoraussetzung zur Teilnahme: sicherer Umgang mit der Kommandozeile, ssh und vim bzw. einem alternativen Editor. Bringst Du mit? Na dann, willkommen zur Weiterbildung!

Aktuell haben wir folgende Termine im Angebot:

Unsere Trainer sind nicht nur im Bereich Schulungen tätig, sondern arbeiten regelmäßig in Software- und Kundenprojekten. Wir wissen, worauf es ankommt und teilen unser Wissen gerne – für Deinen Erfolg!

Erfahre hier mehr zur Terraform Schulung und melde Dich an!

A journey with Vault – Teil 1

Hello fellow blog readers!

Heute möchte ich euch auf die Reise mit Vault by Hashicorp mitnehmen.

Zunächst was ist Vault? Bei Vault handelt es sich stumpf gesagt, um einen Passwortspeicher. Vermutlich kommen da jetzt bei dem einen oder anderen Projekte wie Keypass oder Enpass in den Sinn. Die Richtung ist schon mal gut. Jedoch kennt auch jeder das Hauptproblem der oben genannten Lösungen nur zu gut.

Teamfähigkeit.

Das eine Projekt beherrscht es, andere nur teilweise oder vieleicht sogar garnicht. Frustrierend könnte man die Situation auch gerne umschreiben. Fakt ist auf jeden Fall das es sich bei Vault um eine Lösung handelt, die wirklich das Zeug dazu hat ein Teamfähiger Passwortspeicher zu sein. Wie so alles in der Welt haben Dinge leider ihren Preis. Man wird mit Teamfähigkeit gesegnet, aber Satan bestraft uns indirekt mit der Komplexität des ganzen Konstrukts, weswegen ich das Abenteuer Vault in eine kleine Serie verpacke. Genug Worte für den Einstieg, legen wir los mit dem neuen Abenteuer in der Hautprolle: Vault.

Part Uno widment sich der grundlegenden Inbetriebnahme von Vault.

Wie immer benutzte ich eine mit Vagrant provisionierte höchst aktuelle CentOS 7 Box der Marke Eigenbau mit VirtualBox als Provider.

Die Reise beginnt mit dem Download eines ZIP-Archivs welche das Vault binary enthält. Den legen wir einfach unter /tmp ab und entpacken ihn direkt nach /usr/local/bin

wget https://releases.hashicorp.com/vault/1.3.0/vault_1.3.0_linux_amd64.zip -P /tmp
unzip /tmp/vault_1.3.0_linux_amd64.zip -d /usr/local/bin
chown root. /usr/local/bin/vault

Damit das aufrufen von Vault direkt gelingt müssen wir unsere PATH Variable noch um /usr/local/bin ergänzen. Ich hab das ganze in meinem ~/.bash_profile hinterlegt:

PATH=$PATH:$HOME/bin:/usr/local/bin

Wenn alles korrekt ausgeführt wurde, können wir jetzt die Autocompletion nachziehen und anschließend die Shell neustarten:

vault -autocomplete-install
complete -C /usr/local/bin/vault vault
exec $SHELL

Um das ganze abzurunden lassen wir Vault als Daemon laufen.

Zunächst müssen wir es Vault gestatten mlock syscalls ohne der Notwendigkeit von root ausführen zu dürfen:

setcap cap_ipc_lock=+ep /usr/local/bin/vault

Danach legen wir einen nicht priviligierten Systembenutzer an, unter dem der Vault Daemon später laufen soll:

useradd --system --home /etc/vault.d --shell /bin/false vault

Jetzt kommt die systemd Unit:

touch /etc/systemd/system/vault.service

… mit folgenden Inhalt:

[Unit]
Description="HashiCorp Vault - A tool for managing secrets"
Documentation=https://www.vaultproject.io/docs/
Requires=network-online.target
After=network-online.target
ConditionFileNotEmpty=/etc/vault.d/vault.hcl
StartLimitIntervalSec=60
StartLimitBurst=3

[Service]
User=vault
Group=vault
ProtectSystem=full
ProtectHome=read-only
PrivateTmp=yes
PrivateDevices=yes
SecureBits=keep-caps
AmbientCapabilities=CAP_IPC_LOCK
Capabilities=CAP_IPC_LOCK+ep
CapabilityBoundingSet=CAP_SYSLOG CAP_IPC_LOCK
NoNewPrivileges=yes
ExecStart=/usr/local/bin/vault server -config=/etc/vault.d/vault.hcl
ExecReload=/bin/kill --signal HUP $MAINPID
KillMode=process
KillSignal=SIGINT
Restart=on-failure
RestartSec=5
TimeoutStopSec=30
StartLimitInterval=60
StartLimitIntervalSec=60
StartLimitBurst=3
LimitNOFILE=65536
LimitMEMLOCK=infinity

[Install]
WantedBy=multi-user.target

Bevor wir den Daemon starten können, müssen wir ein paar Verzeichnisse sowie eine Konfigurationsdatei anlegen:
mkdir -pv /etc/vault.d/
mkdir -pv /usr/local/share/vault/data/
chown -R vault. /usr/local/share/vault/

touch /etc/vault.d/vault.hcl

Meine Konfigurationsdatei ist als Beispielhaft anzusehen. Sie behinhaltet das nötigste um den Vault Server grundsätzlich starten zu können. Diese sollte entsprechend an das eigene Szenario angepasst werden und unbedingt mit Zertifikaten ausgestattet sein!

storage "file" {
path = "/usr/local/share/vault/data"
}

ui = true

listener "tcp" {
address = "172.28.128.25:8200"
tls_disable = "true"
}

api_addr = "http://172.28.128.25:8200"
cluster_addr = "http://172.28.128.25:8201"

systemd neuladen und den Vault Daemon starten:

systemctl daemon-reload
systemctl start vault

Wenn uns alles geglückt ist, sollten wir unter der Adresse des Servers, mit Angabe des Ports 8200 nun die UI von Vault vorfinden. Damit geht es nun in der Bildstrecke weiter:

Das wars für den ersten Teil der Serie, im zweiten Teil werden wir uns den Aufbau von Vault genauer anschauen und uns der integration von SSH widment. Vault bietet nämlich viele Integrationsmöglichkeiten mit denen sich am Ende die Authentifizierung von sämtlichen Dienste Zentralisiert über Vault steuern lassen. Bis dahin wünsche ich wie immer viel Spass beim Basteln!

Photo from: https://devopscube.com/setup-hashicorp-vault-beginners-guide/

NWS Cloud and Terraform – does this work?

A few months ago we launched our OpenStack project within our NWS platform. The NWS Cloud was born.
Since then we are trying to increase the performance and the possibilities of the cloud. And nowadays there is no way around Terraform.

So i had a look at the possibilities and had to try them out. One of my first runs should create a virtual machine, create some security rules, attach a public IP to the virtual machine and install a webserver with a customized index.html

And how this works, i want to show now.

 

But first of all, i have to save my credentials in my config file

variables.tf

variable "openstack_user_name" { description = "The username for the Tenant." default = "my-nws-user" } variable "openstack_tenant_name" { description = "The name of the Tenant." default = "my-nws-project" } variable "openstack_password" { description = "The password for the Tenant." default = "my-password" } variable "openstack_auth_url" { description = "The endpoint url to connect to OpenStack." default = "nws-cloud" } variable "openstack_keypair" { description = "The keypair to be used." default = "mgebert" } variable "tenant_network" { description = "The network to be used." default = "my-nws-project" }

With this variables i can now start writing the rest of my files. I had to configure the provider

provider.tf

provider "openstack" { user_name = "${var.openstack_user_name}" tenant_name = "${var.openstack_tenant_name}" password = "${var.openstack_password}" auth_url = "${var.openstack_auth_url}" }

And the “script” which should run on the new virtual machine

bootstrapweb.sh

#!/bin/bash apt update apt install -y apache2 cat <<EOF > /var/www/html/index.html <html> <body> <p>hostname is: $(hostname)</p> </body> </html> EOF chown -R www-data:www-data /var/www/html systemctl apache2 start

But there is still no server right? So i have to write my deploy file.

deploy.tf

resource "openstack_networking_secgroup_v2" "secgroup1" { name = "ALLOW SSH AND HTTP" } resource "openstack_networking_secgroup_rule_v2" "secgroup_rule_1" { direction = "ingress" ethertype = "IPv4" protocol = "tcp" port_range_min = 22 port_range_max = 22 remote_ip_prefix = "0.0.0.0/0" security_group_id = "${openstack_networking_secgroup_v2.secgroup1.id}" } resource "openstack_networking_secgroup_rule_v2" "secgroup_rule_2" { direction = "ingress" ethertype = "IPv4" protocol = "tcp" port_range_min = 80 port_range_max = 80 remote_ip_prefix = "0.0.0.0/0" security_group_id = "${openstack_networking_secgroup_v2.secgroup1.id}" } resource "openstack_networking_secgroup_rule_v2" "secgroup_rule_3" { direction = "ingress" ethertype = "IPv4" protocol = "icmp" remote_ip_prefix = "0.0.0.0/0" security_group_id = "${openstack_networking_secgroup_v2.secgroup1.id}" } resource "openstack_compute_instance_v2" "web" { name = "web01" image_name = "Ubuntu Xenial" availability_zone = "HetznerNBG4" flavor_name = "s2.small" key_pair = "${var.openstack_keypair}" security_groups = ["default","ALLOW SSH AND HTTP"] network { name = "${var.tenant_network}" } user_data = "${file("bootstrapweb.sh")}" } resource "openstack_networking_floatingip_v2" "floating" { pool = "public-network" } resource "openstack_compute_floatingip_associate_v2" "floating" { floating_ip = "${openstack_networking_floatingip_v2.floating.address}" instance_id = "${openstack_compute_instance_v2.web.id}" }

 

In this file i configure first of all the new security group and afterwards 3 rules to allow ICMP, HTTP and SSH. Then we can start the virtual machine with a name, image_name, a flavor_name, security_groups and so on. I could configure more, like a loop which creates me 10 web-servers with the name web-01 to web-10 . But for now, thats fine. When the server is up and running, the deploy will attach a floating IP to it, so i can access it without a VPN.

And thats it, basically. When it is installed, the bootstrapweb.sh will install the apache2 webserver and replace the default index.html with my custom one.

There is almost no setup which can’t be build up with terraform in combination with the NWS Cloud – so just try it yourself

If you want to see the code above in action, have a look at this video!