Managing your Ansible Environment with Galaxy

Ansible is known for its simplicity, lightweight footprint and flexibility to configure nearly any device in your infrastructure. Therefore it’s used in large scale environments shared between teams or departments. This leads to even bigger Ansible environments which need to be tracked or managed in version control systems like Git.

Mostly environments grow with their usage over time, in this case it can happen that all roles are managed inside one big repository. Which will eventually lead to quite messy configuration and loss of knowledge if roles are tested or work the way they supposed to work.

Ansible provides a solution which is called Galaxy, it’s basically a command line tool which keeps your environment structured, lightweight and enforces your roles to be available in a specific version.

First of all you can use the tool to download and manage roles from the Ansible Galaxy which hosts many roles written by open-source enthusiasts. 🙂


# ansible-galaxy install geerlingguy.ntp -v
Using /Users/twening/ansible.cfg as config file
 - downloading role 'ntp', owned by geerlingguy
 - downloading role from https://github.com/geerlingguy/ansible-role-ntp/archive/1.6.4.tar.gz
 - extracting geerlingguy.ntp to /Users/twening/.ansible/roles/geerlingguy.ntp
 - geerlingguy.ntp (1.6.4) was installed successfully

# ansible-galaxy list
# /Users/twening/.ansible/roles
 - geerlingguy.apache, 3.1.0
 - geerlingguy.ntp, 1.6.4
 - geerlingguy.mysql, 2.9.5

Furthermore it can handle roles from your own Git based repository. Tags, branches and commit hashes can be used to ensure it’s installed in the right version.


ansible-galaxy install git+https://github.com/Icinga/ansible-icinga2.git,v0.2.0
 - extracting ansible-icinga2 to /Users/twening/.ansible/roles/ansible-icinga2
 - ansible-icinga2 (v0.2.0) was installed successfully

It’s pretty neat but how does this help us in large environments with hundreds of roles?

The galaxy command can read requirement files, which are passed with the “-r” flag. This requirements.yml file can be a replacement for roles in the roles path and includes all managed roles of the environment.


# vim requirements.yml
- src: https://github.com/Icinga/ansible-icinga2.git
  version: v0.2.0
  name: icinga2

- src: geerlingguy.mysql
  version: 2.9.5
  name: mysql

Then run ansible-galaxy with the “–role-file” parameter and let galaxy manage all your roles.


# ansible-galaxy install -r requirements.yml
 - icinga2 (v0.2.0) is already installed, skipping.
 - downloading role 'mysql', owned by geerlingguy
 - downloading role from https://github.com/geerlingguy/ansible-role-mysql/archive/2.9.5.tar.gz
 - extracting mysql to /Users/twening/.ansible/roles/mysql
 - mysql (2.9.5) was installed successfully

In case you work with Ansible AWX, you can easily replace all your roles with this file in the roles directory and AWX will download and manage your roles directory automatically.

A example project could look like this.


awx_project/
├── example_playbook.yml
├── group_vars
├── host_vars
├── hosts
└── roles
    └── requirements.yml

In summary, in large environments try to keep your code and configuration data separated, try to maintain your roles in their own repository to avoid conflicts at the main project.

Check out our Blog for more awesome posts and if you need help with Ansible send us a message or sign up for one of our trainings!

Thilo Wening
Thilo Wening
Consultant

Thilo hat bei NETWAYS mit der Ausbildung zum Fachinformatiker, Schwerpunkt Systemadministration begonnen und unterstützt nun nach erfolgreich bestandener Prüfung tatkräftig die Kollegen im Consulting. In seiner Freizeit ist er athletisch in der Senkrechten unterwegs und stählt seine Muskeln beim Bouldern. Als richtiger Profi macht er das natürlich am liebsten in der Natur und geht nur noch in Ausnahmefällen in die Kletterhalle.

Graphite-API für Grafana und Icinga Web 2

Ziel dieses Posts ist es, am Ende die Metriken über die Graphite-API als Backend für Grafana und das Icinga-Web-2-Module graphite betreiben zu können.

Grafana übernimmt hierbei optional die Visualisierung über eigene Dashboards, was ansonsten Graphite-Web leistet. Für Icinga Web 2 ist Grafana nur erforderlich, falls nicht das Module graphite zum Einsatz kommen soll, sondern stattdessen grafana zur Darstellung im Icinga Web 2 verwendet werden sollte.

Die Graphite-API ist in Python implementiert und soll hierbei via HTTPS angesprochen werden. Zusätzlich ist der Zugriff via Basis-Authentifizierung zu beschränken. Dies alles überlassen wir dem Apache, auch die API lassen wir mittels WSGI im Apache laufen.

Der Vorteil gegenüber dem Graphite-Web liegt darin, die ganzen Django-Bibliotheken nicht zu benötigen und auch kein DB-Backend a la SQLite, MySQL oder PostgreSQL. Nachteil ist, das Projekt Graphite-API wird nicht vom Graphite-Team betrieben, somit ist die Pflege und Aktualität nicht sichergestellt.
(more…)

Lennart Betz
Lennart Betz
Senior Consultant

Der diplomierte Mathematiker arbeitet bei NETWAYS im Bereich Consulting und bereichert seine Kunden mit seinem Wissen zu Icinga, Nagios und anderen Open Source Administrationstools. Im Büro erleuchtet Lennart seine Kollegen mit fundierten geschichtlichen Vorträgen die seinesgleichen suchen.

Python lernen?

Hier möchte ich meine Erfahrung teilen, wie ich in die Sprache Python eingestiegen bin.

 

Am Anfang der Ausbildung bin ich in PHP eingestiegen und fand die Sprache sehr angenehm.

Dazu gehören natürlich auch die Auszeichnungs-, Definitionsprachen HTML & CSS.

Doch mit der Zeit wurde PHP für mich als Programmier-Neuling immer komplexer.

Im Hinterkopf behielt ich Python, weil ich immer wieder von Programmierern hörte wie einfach diese Sprache sei

und diese auch von ihnen empfohlen wurde.

Zudem soll sie einer der beliebtesten und sehr gut für Beginner sein.

Also was spricht dagegen sie zu lernen?          Richtig. Gar nichts.

Aber wie lernt man eine Programmiersprache? 

Durch Blogs? Durch Videokurse?  Durch Bücher?

Der eine findet Videokurse gut, der andere Blogs und reinen Text. Das ist ganz ok.

Solange man Fortschritte macht, macht man nichts falsch.

Ehrlich gesagt muss man für sich selber herausfinden wie man am besten lernen kann.

Vielleicht mal alle Lernangebote durchstöbern und dann entscheiden was passt.

Ich persönlich habe Bücher sehr in mein Herz eingeschlossen. Ein Grund:

Das Buch liegt direkt vor einem. Videokurse sind etwas umständlicher.

Also habe ich mir ein Buch geholt. Sogar ein sehr gutes von O’REILLY.

Es ist echt wichtig das in einem Buch alles ausführlich erklärt wird. In dem Fall tut es das Buch.

Und wie komme ich mit der Sprache zurecht?

Anders als bei der anderen Sprachen gibt es eine kleine Umstellung.

Und zwar sind die Einrückungen (die Suiten) sehr wichtig. Da wird gleich die Syntax mit geübt.

Daran muss man sich erst gewöhnen. Sonst komme ich zurzeit gut zurecht.

So möchte ich mir mit Python ein weiteres Fundament aufbauen.

Ich kann Python nur weiter empfehlen!

Loei Petrus Marogi
Loei Petrus Marogi
Junior Developer

Loei ist Fachinformatik-Azubi im ersten Lehrjahr und lernt momentan unseren Toolstack kennen. Nach der Linux-Schulung freut er sich besonders aufs Programmieren. Wenn er mal nicht bei NETWAYS ist, spielt er Fußball im Verein oder geht ins Fitnessstudio.

NFC-Leser mit einem Raspberry Pi

In meinem letzten Blogpost habe ich schon etwas über NFC und RFID geschrieben. In diesem Blog erstellen wir einen Leser, mit dem man beispielsweise auch NFC-fähige Karten oder Chips auslesen kann.

Was brauchen wir?

  1. Einen Raspberry Pi
  2. Female-Female Jumperkabel
  3. RFID-Reader MFRC522 Modul

Hier benutze ich das zurzeit das aktuellste Modell des Raspberrys, den 3 B+.

Natürlich sind auch ältere Pi Modelle für dieses Projekt ausreichend.

Die Jumperkabel sowie das Modul können sehr leicht und kostengünstig auf Plattformen wie Amazon oder Ebay gefunden werden.

Verkabelung

Als Erstes nehmen wir uns sieben Jumperkabel her. Am besten verschiedenfarbige Kabel, zur besseren Übersicht.

3,3 V -> Pin 1,    RST -> Pin 22,

GND -> Pin 6,    IRQ -> bleibt frei,

MISO -> Pin 21,    MOSI -> 19,

SCK -> 23,    SDA -> Pin 24

Software

 

Wenn die Verkabelung abgeschlossen ist, können wir mit der Software beginnen.

Zunächst muss das SPI Interface aktiviert werden. Das kann unter “Einstellungen” -> “Raspberry-Pi-Konfiguration” ->

“Schnittstellen” gemacht werden.

Nach einem Neustart kann per Befehl überprüft werden, ob SPI aktiviert ist.

Konsolenbefehl: lsmod | grep spi

Es sollte so eine ähnliche Ausgabe kommen:

Den Code findet ihr hier: SPI Py als Zip Datei, der Ordner kann heruntergeladen und entpackt werden.

Nun wechselt ihr in das  /SPI-Py/MFRC522-python Verzeichnis und führt dort die Read.py Datei aus.

Dies kann man mit dem Befehl  python Read.py  machen.

Zum Schluss den Chip auf den Reader legen.

Wenn alles richtig ist, solltet ihr diese oder ähnliche Ausgabe bekommen:

 

 

Loei Petrus Marogi
Loei Petrus Marogi
Junior Developer

Loei ist Fachinformatik-Azubi im ersten Lehrjahr und lernt momentan unseren Toolstack kennen. Nach der Linux-Schulung freut er sich besonders aufs Programmieren. Wenn er mal nicht bei NETWAYS ist, spielt er Fußball im Verein oder geht ins Fitnessstudio.
FM Empfänger mit dem Raspberry Pi 3

FM Empfänger mit dem Raspberry Pi 3

Es gibt viele Projekte für Einsteiger, um mit einem Raspberry Pi kleineres zu realisieren. Unter anderem ein FM Empfänger, wofür die folgende Anleitung genutzt werden kann.

Materialien: 

  1. Raspberry Pi 3
  2. Female Female Jumper
  3. Tea5767 Modul
  4. Lautsprecher (Beispiel)
  5. AUX Kabel

Vorgehen: 

1) Die mitgelieferte SD Karte enthält bereits ein Noob OS, womit Raspian installiert werden kann. Sollte ein anderes Kit ohne Karte bestellt werden, braucht man natürlich auch eine SD Karte. Noob OS dann einfach herunterladen, entpacken und auf die Karte kopieren

2) I2C aktivieren via: sudo raspi-config
-> Interfacing Options
-> I2C
-> YES

3) Der Raspberry Pi muss natürlich auch mit dem Modul verbunden werden. Hierzu werden die Female-Female Jumper benutzt.
Raspberry Pi    Tea5767
5V              5V
SDA.1           SDA
SCL.1           SCL
GND             GND

Auf welche Pins nun genau gesteckt werden muss, kann mittels gpio readall herausgefunden werden. Falls SDA.1 und SCL.1 bereits in Verwendung sind, kann auch auf 0 oder 2 ausgewichen werden.

4) Ob das Modul auch erkannt wurde, wird folgendermaßen überprüft:
i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: 60 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Die “1” steht hier für SCl.1 und SDA.1 – sollte SDA.0 und SCL.0 verwendet worden sein, muss der Command entsprechend angepasst werden.  Wenn in der angezeigten Tabelle keine Zahl erscheint, wird das Modul nicht erkannt. Dies liegt meist an einer falschen Verkabelung oder einem defekten Modul.

5) Aus einer anderen Anleitung haben wir uns eines Links zum Code bedient, das den Tea5767 steuert. Es kann hier natürlich selbst auch ein Skript geschrieben werden, wenn tiefere Einblicke gewünscht sind. Hierfür wird python3 benötigt sowie verschiedene Module. Beim ersten Aufruf des Skriptes wird aber mitgeteilt, ob etwas nachinstalliert werden muss, oder nicht. Falls das der Fall ist, kann mit pip3 install $modul entsprechend nachjustiert werden.
Unter /home/pi ein neues Verzeichnis (z.B.: PiFM) erstellen und das Skript dort ablegen.

6) Mit python3 radio.py kann nun der eigentliche Radio gestartet werden. Es empfiehlt sich, das Skript kurz durchzulesen, da der Radio über Tasten gesteuert wird. So wird mit “W” die Frequenz um +1 verändert, mit “E” um +0.1

Alles in allem ist das ein schönes Projekt um erste Eindrücke in die Funktionsweise eines Raspberry Pis zu bekommen und wie bestimmte Module funktionieren, verbunden und genutzt werden. Interessant wird das auch, wenn man parallel dazu mit einem 2. Pi einen FM Transmitter aufbaut. Hierzu gibt es in einem späteren Blogpost aber mehr.

Marius Gebert
Marius Gebert
Systems Engineer

Marius ist seit 2013 bei NETWAYS. Er hat 2016 seine Ausbildung zum Fachinformatiker für Systemintegration absolviert und ist nun im Web Services Team tätig. Hier kümmert er sich mit seinen Kollegen um die NWS Plattform und alles was hiermit zusammen hängt. 2017 hat Marius die Prüfung zum Ausbilder abgelegt und kümmert sich in seiner Abteilung um die Ausbildung unserer jungen Kollegen. Seine Freizeit verbringt Marius gerne an der frischen Luft und ist für jeden Spaß zu...

Revisited – Graphite-Web installation unter Debian 9

Erstmal wieso Revisited ?

Dies ist ein update meines älteren Blog Posts Blogpost 2016 welcher darauf einging das unter Debian 8.4 graphite-web wegen eines Fehlenden Eintrages in der Apache 2.4 Konfiguration nicht korrekt gestartet/aufgerufen werden konnte.
Es ist schon einige Zeit ins Land gegangen und ich habe weniger ein Auge darauf geworfen ob das weiterhin so Funktioniert.
Deshalb Revisited.

Here we Go again !

Ich gehe in diesem Fall von einer Debian Version der Nummer 9 aus und werde wie bei dem alten Blogpost. In der Grundannahme mal davon ausgehen das alles Funktioniert wie es soll:
Also hier die folgenden installationschritte:
#> apt-get install apache2 libapache2-mod-wsgi python-django python-django-tagging fontconfig python-tz python-pip python-dev python-twisted python-cairo
#> pip install carbon whisper graphite-web
#> pip install --upgrade twisted
#> cp /opt/graphite/conf/carbon.conf.example /opt/graphite/conf/carbon.conf
#> cp /opt/graphite/conf/storage-schemas.conf.example /opt/graphite/conf/storage-schemas.conf
#> /opt/graphite/bin/carbon-cache.py start
#> /opt/graphite/bin/carbon-cache.py status
#> cp /opt/graphite/examples/example-graphite-vhost.conf /etc/apache2/sites-available/graphite.conf
#> cp /opt/graphite/conf/graphite.wsgi.example /opt/graphite/conf/graphite.wsgi
#> cp /opt/graphite/webapp/graphite/local_settings.py.example \ /opt/graphite/webapp/graphite/local_settings.py
#> python /opt/graphite/webapp/graphite/manage.py syncdb
#> chown www-data. -R /opt/graphite/storage
#> a2dissite 000-default
#> a2ensite graphite
#> a2enmod wsgi
#> service apache2 restart
#> chmod +x /etc/init.d/carbon-cache // Damit 'carbon-cache.py start' mit Systemstart erfolgt

Ergebnis davon ist -> Nichts funktioniert.

Back to the Roots

Ab hier kommt der Weg graphite-web auf einem Debian 9 (Stretch) in Betrieb zu nehmen.
Ausgangspunkt ist ein frisch installiertes Debian 9.
#> apt-get install vim -y
#> vim /etc/apt/sources.list

Wir müssen die Sources auf die Jessie Repositories setzen da zum Zeitpunkt dieses Blogposts die graphite-web Pakete nicht abrufbar sind.
Daher fügen wir folgendes hinzu in der sources.list
deb http://httpredir.debian.org/debian jessie main
Gefolgt von einem frischem #> apt-get update -y .
Nun installieren wir den großteil der Pakete welche wir benötigen.
#> apt-get install graphite-web graphite-carbon mysql-server python-mysqldb python-pymysql apache2 libapache2-mod-wsgi apt-transport-https ssl-cert python-pip -y
Es folgen ca. 300MB an Daten.
Daraufhin stürzen wir uns direkt auf die Konfig.
Wir fangen an folgende Datei zu editieren.
#> vim /etc/graphite/local_settings.py
Darin ändern wir folgende Settings Sinnvoll in etwas was wir für unsere Installation benötigen.
Also SECRET_KEY, TIME_ZONE & ALLOWED_HOSTS setzen.
Danach muss in der folgenden Datei ein “true” gesetzt werden damit graphite & carbon gemeinsam starten.
#> vim /etc/default/graphite-carbon
Nun kommt der trickreichste Part wir sind leider dazu genötigt eine alte django Version zu installieren.
#> pip install "django==1.4"
Damit haben wir die Grundlage womit wir das folgende Kommando erfolgreich absetzen können.
#> graphite-manage syncdb
#> chown _graphite. /var/lib/graphite/graphite.db
HINWEIS ! Dies setzt erst mal die voreingestellte sqlitedb in Gang.
Wenn eine andere DB verwendet werden soll dann sollte dies bitte in der “local_settings.py” vorgenommen werden.
Wir sind fast am Ziel ein funktionierendes graphite-web zu haben.
Es fehlt nur etwas Apache2 Magie.
#>a2dissite 000-default.conf
#>cp /usr/share/graphite-web/apache2-graphite.conf /etc/apache2/sites-available/
#> a2ensite apache2-graphite.conf
#> systemctl restart apache2

Voilà !

Es sollte nun auf dem Host System das graphite-web aufrufbar sein.

Danke für die Aufmerksamkeit !

David Okon
David Okon
Support Engineer

Weltenbummler David hat aus Berlin fast den direkten Weg zu uns nach Nürnberg genommen. Bevor er hier anheuerte, gab es einen kleinen Schlenker nach Irland, England, Frankreich und in die Niederlande. Alles nur, damit er sein Know How als IHK Geprüfter DOSenöffner so sehr vertiefen konnte, dass er vom Apple Consultant den Sprung in unser Professional Services-Team wagen konnte. Er ist stolzer Papa eines Sohnemanns und bei uns mit der Mission unterwegs, unsere Kunden zu...