Select Page

NETWAYS Blog

Warum Python?

Als Systemintegrator in der IT-Welt stellt man früher oder später fest, dass man das Verstehen und Schreiben von Programmiersprachen nicht ignorieren kann. Je nachdem, in welcher IT-Bereich man tätig ist, wird man mit Programmiersprachen konfrontiert.

Wir bei NETWAYS bieten Open Source Lösungen, etwa in den Bereichen Monitoring, Cloud, Log-Management und Schulungen zu diesen Themen und Tools. Unter anderem etwa Lösungen für Automation, wo wir uns hauptsächlich mit Puppet und Ansible als Automation-Tools beschäftigen. Nachdem ich in letzter Zeit bei einigen Automation-Projekten dabei war, habe ich mich also mehr mit Ansible auseinander gesetzt. Ansible ist eine Automatisierungswerkzeug zur Orchestrierung, sowie der allgemeinen Konfiguration und Administration von Computern. Ansible ist Open Source und in Python geschrieben. Dabei bin ich immer wieder in Zusammenhang mit den Ansible-Modulen oder spezifischen Ansibel-Rollen für unsere Kunden auf Python gestoßen. In diesem Blog befassen wir uns mit der Definition und mit Vor- und Nachteilen von Python als Programmiersprache.

Was ist Python?

Programmiersprachen haben eine hohe Vielfalt und jede hat ihre eigenen Verwendungen und Vor- und Nachteile. Eine der objektorientierten Sprachen, die viele Anwendungen hat, ist Python. Python wurde im Jahr 1991 entworfen und veröffentlicht. Python ist Open Source und einfach zu lernen und damit geeignet für den Einsieg in die Welt des Programmierens. Python kann in vielen verschiedenen Bereichen wie Website Design, Softwareentwicklung und Skripting eingesetzt werden. Außerdem können die in Python geschriebenen Codes in einer Vielzahl von Plattformen wie Linux, Windows, Mac, sogar in Mobiltelefonen usw. implementiert werden.

Vorteile

Bedienung

Python ist aufgrund der Nähe zur menschlichen Sprache eine der am einfachsten zu erlernenden Sprachen, insbesondere für Anfänger. Im Vergleich zu Java und C können dieselben Funktionen in weniger Zeilen ausgeführt werden.

Libraries

Python verfügt über viele Standardbibliotheken in verschiedenen Bereichen wie das Internet, Webservice-Tools, Betriebssystemschnittstellen und Protokolle. Die am häufigsten verwendeten Programmieraufgaben werden in Python geschrieben, um die Anzahl der Codezeilen zu reduzieren, die zum Schreiben eines Programms erforderlich sind.

Integration

Python integriert “Application Integration” und verbessert somit die Entwicklung von Webdiensten durch den Aufruf von COM- oder COBRA-Komponenten. Python verfügt über leistungsstarke Steuerungsmöglichkeiten, da sie direkt von C++, C oder Java mit Jython aufgerufen werden kann. Python kann auch XML und andere “Markup Languages” verarbeiten, um auf modernen Betriebssystemen über ähnlichen Bytecode ausgeführt zu werden.

Flexibilität

Python ist sehr flexibel und erlaubt dem Benutzer daher, neue Dinge auszuprobieren. Python hindert den Benutzer nicht daran, etwas anderes auszuprobieren. Andere Programmiersprachen bieten diese Art von Flexibilität und Freiheit nicht und daher ist Python in diesen Fällen eher vorzuziehen.

Nachteile

Geschwindigkeit

Python ist eine interpretierte Sprache und übersetzt daher den Code Zeile für Zeile. Dadurch ist seine Verarbeitungsgeschwindigkeit niedriger als die einiger anderer Sprachen.

Mobilgeräte

Laut vielen Programmierern ist Python keine geeignete Sprache, um in der mobilen Umgebung ausgeführt zu werden. Außerdem erkennen Android und iOS Python nicht, Python kann jedoch im mobilen Umfeld verwendet werden. Dies erfordert jedoch mehr Zeit und diverse Einstellungen.

Speicherverbrauch

Python hat einen sehr hohen Speicherverbrauch. Dies liegt daran, dass es hinsichtlich Datentypen flexibel ist und viel Speicher verwendet. Python ist keine gute Wahl für speicheroptimierte Aufgaben.

Zusammenfassung

Heutzutage gibt es viele Programmiersprachen in der IT-Welt, die auch rege verwendet werden. Jede dieser Sprachen ist in einem bestimmten Bereich stärker als in anderen. Die Wahl der richtigen Programmiersprache beschäftigt viele, die planen in die Welt des Programmierens einzusteigen.

Die Entscheidung, welche Sprache man lernen soll, hängt von der Anwendung ab und persönlichen Interessen.
Python wurde entwickelt, um Produktivität, Lesbarkeit und Benutzerfreundlichkeit zu betonen. Aus meiner persönlichen Erfahrung als Anfänger kann ich sagen, dass es großen Spaß macht, Codes in Python zu schreiben, da die Lernkurve ab einem gewissen Punkt steil nach oben geht. Falls Du es ebenfalls neu lernen und Dich in Python ausprobieren willst, wünsche ich Dir viel Spaß dabei!

Falls Du es bei NETWAYS lernen oder anwenden magst, dann schau Dir doch mal unsere offenen Jobs und Ausbildungsstellen an!

Saeid Hassan-Abadi
Saeid Hassan-Abadi
Systems Engineer

Saeid hat im Juli 2022 seine Ausbildung als Fachinformatiker für Systemintegration bei uns abgeschloßen, und arbeitet nun in Operation-Team. Der gebürtige Perser hat in seinem Heimatland Iran Wirtschaftsindustrie-Ingenieurwesen studiert. Er arbeitet leidenschaftlich gerne am Computer und eignet sich gerne neues Wissen an. Seine Hobbys sind Musik hören, Sport treiben und mit seinen Freunden Zeit verbringen.

Kleine Weihnachtspyramide mit Raspberry Pi

Noch einmal schlafen und dann ist Weihnachten. Passend dazu haben wir von NETWAYS ein kleines Experiment zum selber Nachbauen vorbereitet.

Es handelt sich um eine kleine Weihnachtspyramide, die sich mithilfe von Python Code und ein paar Bauteilen ein wenig bewegt und außerdem noch schön leuchtet. Fast wie ein kleiner Weihnachtsbaum für jeden IT-Begeisterten da draußen.

 

Das braucht Ihr

Bevor wir starten, benötigen wir ein paar Dinge. Zum einen brauchen wir einen Raspberry-Pi mit Raspberry-PI OS. Das Modell spielt hierbei keine Rolle. Außerdem werden drei farbige LEDs, ein Steckbrett, ein kleiner Servo-Motor, ein Taster, sowie zehn GPIO-Verbindungskabel benötigt.

 

Und so funktioniert’s

Wie Ihr das Ganze verbinden müsst, seht Ihr in der Abbildung unten:

Ganz wichtig: Ihr müsst in der Raspberry Pi Konfiguration unter Schnittstellen noch den GPIO-Fernzugriff erlauben!

Der Programmcode lässt die Pyramide nach links und rechts drehen und die LEDs leuchten.

“#!/usr/bin/python
import RPi.GPIO as GPIO
import time

LED = [[17, 22, 10],[10, 22, 17]]
x = 0
t1 = 8
servoPIN = 21

GPIO.setmode(GPIO.BCM)
GPIO.setup(t1, GPIO.IN, GPIO.PUD_DOWN)
GPIO.setup(servoPIN, GPIO.OUT)

pwm = 2.5
a = 2.5
p = GPIO.PWM(servoPIN, 50)
p.start(pwm)

for i in LED[0]:
GPIO.setup(i, GPIO.OUT)

try:
while True:
p.ChangeDutyCycle(pwm)
pwm += a
if pwm==12.5 or pwm==2.5:
a = -a
time.sleep(0.2)
p.ChangeDutyCycle(0)
for i in LED[x]:
GPIO.output(i, True)
time.sleep(0.2)
GPIO.output(i, False)
if GPIO.input(t1) == True:
x = 1-x

except KeyboardInterrupt:
p.stop()
GPIO.cleanup()”

 

Wie Ihr Eure Pyramide, die auf den Servomotor gesetzt wird, gestaltet, ist Euch selbst überlassen.

Wie das ganze aussehen könnte, seht Ihr hier:

Viel Spaß beim Ausprobieren und fröhliche Weihnachten!

Wenn Ihr wissen wollt, wie wir bei NETWAYS unsere Weihachtsfeier gefeiert haben, lest Euch doch unseren Blogpost zur Weihnachtsfeier durch.

Christoph Breit
Christoph Breit
Junior Consultant

Christoph ist seit Juli 2022 Teil der NETWAYS Professional Services Abteilung. Er absolvierte hier zunächst ein Praktikum und unterstützt sein Team ab September als auszubildender Fachinformatiker für Systemintegration. In seiner Freizeit bereist er gerne die Welt, ist als Basketballer sportlich unterwegs und sitzt auch mal gerne sowohl beim Zocken als auch beim Graphic- & Motion-Designen vorm PC.

Ansible – Testing roles with Molecule

Ansible is a widely used and a powerful open-source configuration and deployment management tool. It can be used for simple repetitive daily tasks or complex application deployments, therefore Ansible is able to cover mostly any situation.

If used in complex or heterogene environments it is necessary to test the code to reduce time to fix code in production. To test Ansible code it is suggested to use Molecule.

Molecule is a useful tool to run automated tests on Ansible roles or collections. It helps with unit tests to ensure properly working code on different systems. Whether using the role internally or provide it to the public, it is useful to test many cases your role can be used. In addition Molecule is easily integrated into known CI/CD tools, like Github Actions or Gitlab CI/CD.

In this short introduction I’ll try get your first Molecule tests configured and running!

Please make sure you installed Molecule beforehand. On most distributions it’s easily installed via PIP.
The fastest and most common way to test roles would be in container. Due to a version problem with systemd currently it’s not possible to start services over systemd in containers. For this reason you can easily start with a vagrant instance and later migrate to docker or podman easily.


pip install molecule molecule-vagrant

If you have a role you can change into the role directory and create a default scenario.


cd ~/Documents/netways/git/thilo.my_config/
molecule init scenario -r thilo.my_config default
INFO     Initializing new scenario default...
INFO     Initialized scenario in /Users/thilo/Documents/netways/git/thilo.my_config/molecule/default successfully.

Below the molecule folder all scenarios are listed. Edit the default/molecule.yml to add the vagrant options.

Add a dependency file with your collections as with newer Ansible versions only the core is available. If needed you can add sudo privileges to your tests.

molecule/default/molecule.yml


---
dependency:
  name: galaxy
  options:
    requirements-file: collections.yml
driver:
  name: vagrant
platforms:
  - name: instance
    box: bento/centos-7
provisioner:
  name: ansible
verifier:
  name: testinfra
  options:
    sudo: true

The converge.yml is basically the playbook to run on your instance. In the playbook you define which variables should be used or if some pre-tasks should be run.

molecule/default/converge.yml


---
- name: Converge
  hosts: all
  become: true
  tasks:
    - name: "Include thilo.my_config"
      include_role:
        name: "thilo.my_config"

Now you can run your playbook with molecule. If you want to deploy and not delete your instance use converge. Otherwise you can use test, then the instance will be created, tested and destroyed afterwards.


python3 -m molecule converge -s default
or 
python3 -m molecule test -s default

Finally we can define some tests, the right tool is testinfra. Testinfra provides different modules to gather informations and check them if they have specific attributes.

Your scenario creates a tests folder with the following file: molecule/default/tests/test_default.py

In this example I’ll test the resources my role should create.


"""Role testing files using testinfra."""


def test_user(host):
    """Validate created user"""
    u = host.user("thilo")

    assert u.exists

def test_authorized_keys(host):
    """Validate pub key deployment"""
    f = host.file("/home/thilo/.ssh/authorized_keys")

    assert f.exists
    assert f.content_string == "ssh-rsa AAAA[...] \n"

And if we already converged our instance, we can verify these definitions against our deployment.


python3 -m molecule verify
INFO     default scenario test matrix: verify
INFO     Performing prerun with role_name_check=0...
[...]
INFO     Running default > verify
INFO     Executing Testinfra tests found in /Users/thilo/Documents/netways/git/thilo.my_config/molecule/default/tests/...
============================= test session starts ==============================
platform darwin -- Python 3.9.12, pytest-6.2.5, py-1.11.0, pluggy-0.13.1
rootdir: /
plugins: testinfra-6.4.0
collected 2 items

molecule/default/tests/test_default.py ..                                [100%]

============================== 2 passed in 1.79s ===============================
INFO     Verifier completed successfully.

With those easy steps you can easily test your roles for any scenario and your deployments can run without any hassle or at least you will be more relaxed during it 😉

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
Manager Consulting

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.

Python – Generator

Wer schon einmal eine etwas größere Datei, bspw. 1Gb, mit dem Editor VIM geöffnet hat, der weis, wie lange dies dauern kann. Das kommt daher, dass diese Datei zunächst komplett in den Arbeitsspeicher geladen werden muss. So ähnlich verhält es sich, wenn in Python eine Variable “befüllt” wird, welche anschließend Speicherplatz im Arbeitsspeicher belegt. Bei der heutigen Hardware stellen 1 Gb große Variablen kein Problem dar, aber was passiert wenn diese deutlich größer sind und zusätzlich eine gute Performance benötigt wird? In diesem Fall empfiehlt es sich, auf einen Generator zurückzugreifen. Ein Generator liefert lapidar gesagt die Ergebnisse einer Funktion “häppchenweise” und nicht als riesiges Stück zurück. Syntaktisch unterscheidet sich ein Generator von einer “normalen” Funktion nicht großartig, wie hier zu sehen:

def a_function():
  yield x
  yield y
  yield z

Bei der Funktionsdefinition wird lediglich das Schlüsselwort return durch yield ersetzt. Der große Unterschied zu einer “normalen” Funktion dabei ist, dass sich die Funktion mit yield nicht sofort beendet. Somit erhält man, vereinfacht gesagt, ein Objekt (Iterator) als Rückgabewert, über das man iterieren kann.

Zur besseren Veranschaulichung eines Generators werde ich eine exemplarische Datenbankabfrage aufzeigen:

Hinweis: Ich habe eine Beispieldatenbank genommen.

“normale” Funktion
SELECT-Statement und anschließende Rückgabe des gesamten Ergebnisses:

def select_list():
    result = []

    db = mysql.connector.connect(host='127.0.0.1',
                                 user='thomas',
                                 password="4nD3r5on",
                                 db='employees')

    cursor = db.cursor()

    cursor.execute('select * from employees')

    for row in cursor:
        result.append(row)

    return result

Die Funktion “select_list()” liefert eine Liste zurück:

print(select_list())

[...]
(10016,'1961-05-02','Kazuhito','Cappelletti','M','1995-01-27'),
(10017,'1958-07-06','Cristinel','Bouloucos','F','1993-08-03'),
(10018,'1954-06-19','Kazuhide','Peha','F','1987-04-03'),
[...]

“generator” Funktion
Im Gegensatz zum obigen Beispiel wird keine Liste mit den Werten befüllt, sondern jeder Wert einzeln durch yield zurückgegeben:

def select_generator():
    db = mysql.connector.connect(host='127.0.0.1',
                                 user='thomas',
                                 password="4nD3r5on",
                                 db='employees')

    cursor = db.cursor()

    cursor.execute('select * from employees')

    for row in cursor.fetchmany(1000):
        yield row

Die Funktion “select_generator()” liefert keine Liste zurück, sondern einen Generator:

print(select_generator())

<generator object select_generator at 0x10ba165d0>

Durch anschließendes Iterieren des Generatorsobjektes werden die gewünschten Werte ausgegeben:

for row in select_generator():
        print(row)

[...]
(10016,'1961-05-02','Kazuhito','Cappelletti','M','1995-01-27'),
(10017,'1958-07-06','Cristinel','Bouloucos','F','1993-08-03'),
(10018,'1954-06-19','Kazuhide','Peha','F','1987-04-03'),
[...]

Wo liegt nun der Vorteil eines Generators? Das zeigt sich erst bei Benchmark-Tests, welche im folgenden Beispiel die Performance der jeweiligen Funktion aufzeigt. Die SELECT-Statements sind bei beiden Beispielen dieselbigen, werden aber nicht ausgegeben, es wird nur eine Variable initialisiert:
select_list()

print('Memory (Before): {} Mb'.format(
    psutil.Process(os.getpid()).memory_info().rss / 1000000))
    
t1_start = perf_counter()
test_list = select_list()
t1_stop = perf_counter()
    
print('Memory (After) : {} Mb'.format(
    psutil.Process(os.getpid()).memory_info().rss / 1000000))

print("Elapsed time: {0} seconds".format(t1_stop-t1_start))

select_generator()

print('Memory (Before): {} Mb'.format(
    psutil.Process(os.getpid()).memory_info().rss / 1000000))

t1_start = perf_counter()
test_generator = select_generator()
t1_stop = perf_counter()

print('Memory (After) : {} Mb'.format(
    psutil.Process(os.getpid()).memory_info().rss / 1000000))

print("Elapsed time: {0} seconds".format(t1_stop-t1_start))

select_list():

Memory (Before): 11.776 Mb
Memory (After) : 124.960768 Mb
Elapsed time: 8.311030800000001 seconds

 

select_generator():

Memory (Before): 11.698176 Mb
Memory (After) : 11.718656 Mb
Elapsed time: 4.869999999934649e-07 seconds

Die Zahlen sprechen für sich. Beim Generator bleibt der Verbrauch des Arbeitsspeichers so gut wie unverändert, da dieser beim Ausführen des Codes nicht “alle Werte speichert”, sondern jeden einzelnen Wert ab dem Schlüsselwort yield zurückgibt. Dadurch ergibt sich auch die immense Geschwindigkeit.
An dieser Stelle ist noch zu erwähnen, dass alle Vorteile eines Generators verloren gehen, wenn man diesen in ein Liste umwandelt.

Quelle: https://media.giphy.com/media/yUrUb9fYz6x7a/giphy.gif

Ansible – How to create reusable tasks

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. Often tasks could be used in multiple playbooks to combine update routines, setting downtimes at an API or update data at the central asset management.

To use external tasks in Ansible we use the include_task module. This module dynamically includes the tasks from the given file. When used in a specific plays we would assign play specific variables to avoid confusion. For example:


vim tasks/get_ldap_user.yml

- name: get user from ldap
  register: users
  community.general.ldap_search:
    bind_pw: "{{ myplay_ad_bind_pw }}"
    bind_dn: "{{ myplay_ad_bind_dn }}"
    server_uri: "{{ myplay_ad_server }}"
    dn: "{{ myplay_ad_user_dn }}"
    filter: "(&(ObjectClass=user)(objectCategory=person)(mail={{ myplay_usermail }}))"
    scope: children
    attrs:
      - cn
      - mail
      - memberOf
      - distinguishedName

If this task should be used in another playbook to reduce the amount of code or is used again with other conditions or values. Therefore the variables need to be overwritten or if it is another playbook the variables are named wrong.

The solve this problem change the variables to unused generic variables. And assign your own variables in the include_task statement.


vim tasks/get_ldap_user.yml

- name: get user from ldap
  register: users
  community.general.ldap_search:
    bind_pw: "{{ _ad_bind_pw }}"
    bind_dn: "{{ _ad_bind_dn }}"
    server_uri: "{{ _ad_server }}"
    dn: "{{ _ad_user_dn }}"
    filter: "(&(ObjectClass=user)(objectCategory=person)(mail={{ _ad_usermail }}))"
    scope: children
    attrs:
      - cn
      - mail
      - memberOf
      - distinguishedName

The include_task vars parameter provides own variables to the tasks.


vim plays/user_management.yml
[...]
- name: check if user exists in ldap
  include_tasks:
    file: tasks/get_ldap_user.yml
  vars: 
    _ad_bind_pw: "{{ play_ad_pw }}"
    _ad_bind_dn: "{{ play_ad_user }}"
    _ad_server: "{{ play_ad_server }}"
    _ad_user_dn: "OU=users,DC=example,DC=de"
    _ad_usermail: "{{ play_usermail }}"

This can be easily combined with loops, to enhance the reusability of your tasks even more! Checkout this blogpost about looping multiple tasks. Ansible – Loop over multiple tasks

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
Manager Consulting

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.