Ansible can talk to your favorite API

Ansible is a powerful opensource config management and deployment tool, which can manage nearly any situtation. In many “DevOp” scenarios we come across multiple platforms, which we need to combine. Mostly applications provide an REST Api or web connectors to manage resources, jobs and deployments within the product.
Ansible provides various modules which can execute commands at specific APIs, such as the vmware-guest-module to create virtual machines or the jenkins-job-module to manage jobs over the Jenkins API.
In cases where no module is available, we can use the module “uri”.

The module takes several parameters, of which the “url” is the only required one. For this example I picked an example online API “http://dummy.restapiexample.com/”.
To get a list of all employees we use the method GET on http://dummy.restapiexample.com/api/v1/employees, the header Accept: application/json and register the content.


- name: Make requests to example api
  hosts: localhost
  connection: local
  tasks:
    - name: list employees
      uri:
        method: GET
        url: "http://dummy.restapiexample.com/api/v1/employees"
        return_content: yes
        headers:
          Accept: application/json
      register: response

    - debug:
        msg: "{{ response.content }}"

# Result
TASK [list employees] *************************************************************************
ok: [localhost]

TASK [debug] **********************************************************************************
ok: [localhost] => {
    "msg": [
        {
            "employee_age": "23",
            "employee_name": "test",
            "employee_salary": "46000",
            "id": "12008",
            "profile_image": ""
        }
    ]
}

Now we create a new user in our application, for this we talk to a different url http://dummy.restapiexample.com/api/v1/create and send a body with our user to create.
When the api accepts JSON I use a little trick to generate a valid json body out of yaml variables with the Ansible filter to_json

For this we create a variable with the same key value structure as the API expects it, in this case the structure looks like this {“name”:”test”,”salary”:”123″,”age”:”23″}.


- name: Make requests to example api
  hosts: localhost
  connection: local
  vars:
    data:
      chris:
        name: chris
        salary: 46000
        age: 27
      jessy:
        name: jessy
        salary: 70000
        age: 30
  tasks:
    - name: create employee
      uri:
        method: POST
        url: "http://dummy.restapiexample.com/api/v1/create"
        return_content: yes
        headers:
          Accept: application/json
        body_format: json
        body: "{{ item.value | to_json }}" //Render valid json from each dictionary in the variable data.
      with_dict: "{{ data }}"
      register: post_content

    - debug:
        msg: "{{ item.content }}"
      with_items: "{{ post_content.results }}"

# Result
ansible-playbook create_user.yaml

PLAY [Make requests to example api] ********************************************************************

TASK [Gathering Facts] *********************************************************************************
ok: [localhost]

TASK [create employee] *********************************************************************************
ok: [localhost] => (item={'value': {u'salary': 46000, u'age': 27, u'name': u'chris'}, 'key': u'chris'})
ok: [localhost] => (item={'value': {u'salary': 70000, u'age': 30, u'name': u'jessy'}, 'key': u'jessy'})

With this information given, you can now explore your own favorite API and hopefully reduce your daily tasks as simple Ansible playbooks.

Check out our Blog for more awesome posts and if you need help with Ansible send us a message!

Thilo Wening
Thilo Wening
Senior 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.

i-doit API create, update, delete

Wie in meinem letzten Blogpost angekündigt, werde ich anhand eines Beispiels zeigen, wie man mittels der i-doit-API Daten erstellen, aktualisieren und löschen kann.
Ein großer Vorteil den man durch das Benutzen der i-doit-API hat, ist der, dass man nicht “wie üblich” mit SQL-Statements interne Verarbeitungsschritte innerhalb der Datenbank umgeht. Dadurch kann es nicht passieren, dass man durch z.B. einem UPDATE-Statement einen Datensatz so verändert, dass dieser fehlerhaft wird. Somit ist die Datenintegrität mit der API gewährleistet.
Zunächst sucht man sich das Objekt aus der CMDB heraus welches man verändern will (im folgenden Beispiel das Modell eines bestehenden Servers):

curl -s --data '{ "jsonrpc":"2.0","id":"1","method":"cmdb.category.read", \
"params":{ "apikey":"random_key","objID":"random_objectid","category":"C__CATG__MODEL"}}' \
--header "Content-Type: application/json" https://example-idoit-web-gui.de/src/jsonrpc.php \
| python -m json.tool

Man erhält durch diese Anfrage folgende Antwort:

{
    "id": "1",
    "jsonrpc": "2.0",
    "result": []
}

Wie man sieht ist das result null. D.h. dieser Server/Objekt besitzt keinen Eintrag zu einem Modell bzw. Hersteller. Somit kann man nun ein neues Modell hinzufügen.
Zu beachten ist, dass im Voraus schon Modelle bzw. Hersteller in der CMDB angelegt wurden!

Die zu benutzende Methode ist cmdb.category.create:

curl -s --data '{ "jsonrpc":"2.0","id":"1","method":"cmdb.category.create", \
"params":{ "apikey":"random_key","objID":"random_objectid","category":"C__CATG__MODEL",\
"data":{ "manufacturer": "random_manufacturer","title":"random_modelname","serial":"1234"}}}' \
--header "Content-Type: application/json" https://example-idoit-web-gui.de/src/jsonrpc.php \
| python -m json.tool

Sollte alles funktioniert haben, bekommt man folgenden Response zurück:

{
  "jsonrpc": "2.0",
  "result": {
    "id": "855",
    "message": "Category entry successfully created.",
    "success": true
  },
  "id": "1"
}

Hat man z.B. die Seriennummer falsch eingetragen und möchte diese verändern, kann man dies mit der Methode update durchführen.
cmdb.category.update

curl -s --data '{ "jsonrpc":"2.0","id":"1","method":"cmdb.category.update", \
"params":{ "apikey":"random_key","objID":"random_objectid","category":"C__CATG__MODEL",\
"data":{ "serial":"4321"}}' --header "Content-Type: application/json" https://example-idoit-web-gui.de/src/jsonrpc.php \
| python -m json.tool

Im Anschluss kann man überprüfen ob alle eingetragenen Daten stimmen, indem man wieder den Server ausliest (oberes Beispiel cmdb.category.read):

{
  "jsonrpc": "2.0",
  "result": [{
    "id": "855",
    "objID": "random_objectid",
    "manufacturer": {
      "id": "13",
      "title": "random_manufacturer",
      "const": null,
      "title_lang": "random_manufacturer"
    },
    "title": {
      "id": "3",
      "title": "random_modelname",
      "const": null,
      "title_lang": "random_modelname"
    },
    "productid": "",
    "service_tag": "",
    "serial": "4321",
    "firmware": "",
    "description": ""
  }],
  "id": "1"
}

Zum Schluss löschen wir den Server komplett mittels der Methode quickpurge (quickpurge muss in i-doit aktiviert sein!)
cmdb.category.quickpurge:

curl -s --data '{ "jsonrpc":"2.0","id":"1","method":"cmdb.category.quickpurge", \
"params":{ "apikey":"random_key","id":"random_objectid","\
--header "Content-Type: application/json" https://example-idoit-web-gui.de/src/jsonrpc.php \
| python -m json.tool

 

{
  "jsonrpc": "2.0",
  "result": {
    "message": "Object(s) successfully purged",
    "success": true
  },
  "id": "1"
}

Quickpurge ist eine Methode bei denen die drei Löschschritte (archivieren, löschen, purge) automatisch hintereinander ausgeführt werden. Ansonsten müsste man der Methode cmdb.object.delete die verschiedenen Status in folgender Reihenfolge mitschicken:

{
  ...
  "status": "C__RECORD_STATUS__ARCHIVED"
  ...
}
{
  ...
  "status": "C__RECORD_STATUS__DELETED"
  ...
}
{
  ...
  "status": "C__RECORD_STATUS__PURGE"
  ...
}

Im nächsten Teil der Serien zeige ich wie man mit einem Ruby-Script all diese Schritte automatisiert durchführen kann.

Philipp Dorschner
Philipp Dorschner
Junior Consultant

Philipp hat im September 2017 seine Ausbildung zum Fachinformatiker gestartet. Er hat sogar schon eine Ausbildung im Gepäck und zwar zum technischen Assistenten für Informatik. Danach hat hat er sein Abi nachgeholt und anschließend begonnen Wirtschaftswissenschaften zu studieren. Da sein Herz während des Studiums ständig nach technischen Inhalten geschrien hat, wechselte er zu Verfahrenstechnik. Aber auch dieses Studium konnte Ihn nicht erfüllen, weshalb er sich für die Ausbildung bei NETWAYS entschieden hat, "back to the...

i-doit API

Als IT-Dienstleister bieten wir nicht nur Web Services oder Schulungen, sondern unter anderem auch Hosting an. Im Hosting-Bereich ist eine umfassende und geordnete IT-Dokumentation zwingend erforderlich um ein reibungsloses Arbeiten zu ermöglichen.  Als Lösung wird eine sog. CMDB (Configuration Management Database) eingesetzt, welche nicht nur als eine Inventarisierungs-Datenbank dient, sondern auch die gegenseitigen Abhängigkeiten der Objekte verwaltet. I-doit ist eine solche CMDB.
Seit der i-doit Version 1.8 ist die API kein Bestandteil der Pro-Version mehr und wird als separates Modul ausgeliefert welches frei verfügbar ist. Infolge dessen hab ich ein Azubiprojekt bekommen bei dem man die Funktionsweise einer API kennenlernen kann. Ich zeige im ersten Teil der i-doit API Serie wie man einen Request  über den curl – Befehl versendet.

Hat man die API über die Web GUI von i-doit konfiguriert kann man über folgende URL, welche an die Basis-URL angehängt wird, zugreifen:

/src/jsonrpc.php

Die Programmierschnittstelle kann auf Daten der CMDB über das JSON-Format zugreifen, d.h. es werden JSON-RPC Requests per HTTP-Post an i-doit geschickt und als JSON-RPC Response (mit HTTP-Header application/json) zurückgegeben. Somit kann man entweder über den curl – Befehl oder über einen RESTClient (z.B. als Firefox-Addon) die API ansprechen.
Ein beispielhafter Aufbau eines Request könnte folgendermaßen aussehen :

{
  "jsonrpc": "2.0",
  "id": "1",
  "method": "cmdb.objects.read",
  "params": {
    "apikey": "random_key",
    "filter": {
      "type": "4"
    }
  }
}
  • jsonrpc – version: Da i-doit ausschließlich die Version 2.0 des RPC-Request untersützt
  • id: Ein optionaler skalarer Wert (True, False, String, Numer) welcher aber nicht Null sein darf. Lässt man diesen Parameter aus, so wird lediglich eine Mitteilung verschickt, sodass der Server keine Rückmeldung generiert
  • method: Die zu aufrufende Methode
  • params: Parameter welche an die Methode übergeben werden
curl -s --data '{"jsonrpc":"2.0","id":"1","method":"cmdb.objects.read","params": \
{"apikey":"random_key","filter":{"type":"4"}}}' \
--header "Content-Type: application/json" \
https://example-idoit-web-gui.de/src/jsonrpc.php | python -m json.tool

Mit diesem Request lesen wir alle Objekte in der CMDB aus welche dem Typ 4 (Rack) entsprechen:

{
  "id": "1",
  "jsonrpc": "2.0",
  "result": [{
    "cmdb_status": "6",
    "cmdb_status_title": "in operation",
    "created": "2018-01-05 11:32:13",
    "id": "33",
    "image": "https://example-idoit-web-gui.de/images/objecttypes/something.png",
    "status": "2",
    "sysid": "SYSID_[RANDOMNUMBER_3849274329]",
    "title": "RacknameXYZ",
    "type": "4",
    "type_group_title": "Infrastructure",
    "type_title": "Rack",
    "updated": "2018-01-11 13:38:09"
  },
  {
    ...
    ...
  }]
}

Um z.B. alle Informationen einer Kategorie eines Objektes auslesen zu können, benutzt man die Methode cmdb.category.read:

curl -s --data '{"jsonrpc":"2.0","id":"1","method":"cmdb.category.read","params": \
{"apikey":"random_key","objID":"1234","category":"C__CATG__MODEL"}' \
--header "Content-Type: application/json" \
https://example-idoit-web-gui.de/src/jsonrpc.php | python -m json.tool

Response:

{
  "id": "1",
  "jsonrpc": "2.0",
  "result": [{
    "description": "",
    "firmware": "",
    "id": "307",
    "manufacturer": {
      "const": null,
      "id": "5",
      "title": "Random_Manufacturer_Name",
      "title_lang": "Random_Manufacturer_Name"
    },
  "objID": "Uniqe-Object-ID",
  "productid": "",
  "serial": "1235265477457",
  "service_tag": "",
  "title": {
    "const": null,
    "id": "71",
    "title": "XYZ1234",
    "title_lang": "XYZ1234"
  }
  }]
}

Eine ausführliche Liste aller in i-doit benutzten Kategorien kann man unter folgendem URL-Anhang aufrufen:

https://example-idoit-web-gui.de/index.php?load=api_properties

Darüber hinaus kann man über die i-doit API nicht nur Daten aus einer CMDB herauslesen, sondern auch erstellen, aktualisieren oder löschen. Diese Methoden werde ich im Teil 2 dieser Serie abhandeln.
 
Quellen: i-doit Knowledge Base



Philipp Dorschner
Philipp Dorschner
Junior Consultant

Philipp hat im September 2017 seine Ausbildung zum Fachinformatiker gestartet. Er hat sogar schon eine Ausbildung im Gepäck und zwar zum technischen Assistenten für Informatik. Danach hat hat er sein Abi nachgeholt und anschließend begonnen Wirtschaftswissenschaften zu studieren. Da sein Herz während des Studiums ständig nach technischen Inhalten geschrien hat, wechselte er zu Verfahrenstechnik. Aber auch dieses Studium konnte Ihn nicht erfüllen, weshalb er sich für die Ausbildung bei NETWAYS entschieden hat, "back to the...

GUI REST clients

Mittlerweile sind HTTP REST APIs aus der täglichen Arbeit in der IT nicht mehr wegzudenken. Noch vor Jahren durchaus als exotisch zu bezeichnen, ohne Dokumentation und chaotisch verwoben, entstehen immer mehr gute APIs die sich an entsprechende Standards halten und sinnvolle Funktion bieten. Angefangen von atmosphärischen Zufallszahlen, randomisierten Bildern  oder Kartendecks ist mittlerweile alles aus Microservices zu holen – man denke nur an die 125726 Google APIs. Übrigens bieten wir mit Icinga 2 oder Icinga Web 2 standardisierte APIs für die Monitoring-Umgebung an und ein nicht geringer Anteil unserer Routine besteht mit der Arbeit dieser APIs.
Um effektiv mit den Schnittstellen arbeiten zu können muss man sich diese etwas genauer anschauen. Am besten geht das mit entsprechenden Tools und einer Handvoll guter Features, z.B.:

  • Repetitive Anfragen
  • Absteigende URLs
  • Header, Parameter, Request Body, Cookies
  • Authentifizierung
  • Organisation (Sammlungen, Request-Historie)
  • Binary Daten
  • Pretty Print der Rückgaben

Ich bin mittlerweile unter macOS bei zwei Tools hängengeblieben die gerne einmal zeigen möchte: CocoaRestClient und Postman. Beide Tools besitzen oben genannte Features. Postman gibt es sogar als Chrome App. Bei Verwendung von Chrome und debugging von JavaScript kommt also gleich alles aus einem Guss ;-). Postman ist insgesamt mehr Feature-Complete und die native Cocoa macOS App unglaublich fix. Und natürlich hat auch Curl seine Berechtigung – wenn auch kein GUI!
Es folgt noch eine kleine Photostrecke. Dann ist die eigene Meinung gefragt…

 

Marius Hein
Marius Hein
Head of Development

Marius Hein ist schon seit 2003 bei NETWAYS. Er hat hier seine Ausbildung zum Fachinformatiker absolviert, dann als Application Developer gearbeitet und ist nun Leiter der Softwareentwicklung. Ausserdem ist er Mitglied im Icinga Team und verantwortet dort das Icinga Web.

Einführung zu CouchDB

Bei CouchDB handelt es sich um ein in Erlang geschriebenes dokumentenbasiertes DBMS, das durch sein Design einige interessante Features anbietet.
Die meisten Linux-Distributionen bieten bereits vorgefertigte Pakete an. Unter Ubuntu kann CouchDB z.B. wie folgt installiert werden:
$ sudo apt-get install couchdb
Für den Zugriff auf CouchDB-Datenbanken sind keine speziellen Client-Anwendungen notwendig. Da CouchDB eine HTTP-basierte REST-Schnittstelle anbietet, kann nahezu jeder beliebige HTTP-Client (z.B. curl) verwendet werden, um auf die Daten zuzugreifen.
CouchDB bietet dennoch von Haus aus eine einfache Oberfläche zum Administrieren und Bearbeiten von Datenbanken an. Standardmäßig ist dieses unter http://localhost:5984/_utils/ erreichbar.
Im Gegensatz zu relationalen Datenbanksystemen ist es bei CouchDB nach dem Anlegen einer Datenbank nicht notwendig, ein Datenbankschema in Form von Tabellen zu definieren.
Stattdessen werden JSON-formatierte Dokumente direkt in der Datenbank abgelegt. Jedes Dokument verfügt dabei zunächst nur über zwei Felder:

  • _id: ein eindeutiger Bezeichner für das jeweilige Dokument; wird er vom Benutzer nicht mit angegeben, vergibt CouchDB automatisch eine einzigartige ID
  • _rev: die Revisionsnummer des Dokuments; sie wird bei jedem Update hochgezählt und intern von CouchDB zur Lösung von Konflikten verwendet

Weitere Felder können nach Bedarf beliebig hinzugefügt werden. Dabei ist es möglich, dass mehrere Dokumente unterschiedliche Felder enthalten.
Ein Zugriff auf die Dokumente ist über das _id-Feld möglich. Um über andere Felder nach Dokumenten zu suchen, müssen Views definiert werden. Diese bestehen aus JavaScript-Funktionen, die Dokumente bestimmten Schlüsseln zuordnet.
Um beispielsweise bei einem Blog alle Posts finden zu können, die an einem Donnerstag veröffentlicht wurden, könnte man eine View definieren, die den einzelnen Wochentagen jeweils die entsprechenden Blog-Posts zuordnet. Über die optionale Integration von Apache Lucene ist es auch möglich, Volltextsuchen durchzuführen.
Views werden beim Bearbeiten von Dokumenten aktualisiert und verwenden intern einen binären Baum, um eine ähnliche Performance anzubieten wie Indizes bei relationalen Datenbanksystemen.
Mehr Informationen zu CouchDB-Features wie z.B. Replikation, Dokumenten-Validierung und etlichen weiteren gibt es auf der offiziellen Webseite unter http://couchdb.apache.org/ und im online verfügbaren Buch “CouchDB: The Definitive Guide
” unter http://guide.couchdb.org/.

Weekly Snap: RT for mobiles, REST, Nagios Training and Jobs galore

9-13 August offered two jobs, Nagios training courses, Request  Tracker mobile interface and look into the REST architectural style.
Julian tipped off a new mobile web interface for Request Tracker. The plugin automatically recognises the iPhone, Android and Blackberry, offering an optimised display of tickets and history. Tickets can be created and searched, attachments downloaded, and authenthication can be normal or external.
Karo was on the hunt for new colleagues to join the NETWAYS team, posting two positions – a Systems Engineer and a Developer. The Systems Engineer will join the Managed Services boys to implement and maintain internet platforms and independent projects, support customers on 1st and 2nd levels, prepare documentation and handover to customers. Of course all is based on open source and experience with Linux, MySQL, LVS, Heartbeat, DRBD is necessary. The Developer will have good knowledge of PHP and MVC frameworks, web technologies (HTML, AJAX, XML, XSLT and Java Script), Perl, and Object Oriented Perl, Eclipse GIT and Subversion, databanks (MySQL, PostgreSQL) and Linux systems and network technologies (Debian, Ubuntu). Applicants who enjoy customer contact and working on their own initiative are welcome to apply.
Bernd continued his development series on SOAP and REST with a look at the architecutural style of REST. As opposed to SOAP, Representational State Transfer offers an architectural model that is often found in the www,and a concrete method to deal with such interfaces. With the classic web commands- GET, POST, PUT and DELETE, developers can quickly and easily create applications, without needing to keep to defined transfer formats that SOAP requires. The decision lies however in the complexity and need for complex transactions to be bundled and routed. Most systems do come out nonetheless fine with REST and benefit from its simplicity.
Finally Manuela announced the latest dates for our Nagios training course for newbies. If you want to learn how Nagios works, how to configure it and monitor Windows and integrate SNMP based network components, keep the 6-9 September or 15-18 November free – or register with our „Blog 10%“ code to get 10% discount. Hope to see you there!

Architekturstile: REST

Vor einiger Zeit sind wir ja bereits auf SOAP intensiv eingegangen. SOAP ist zwar zu Beginn oft Komplex und konfrontiert die Entwickler mit einer etwas anstrengenderen Lernkurve, spielt jedoch auf der Geraden den ein oder anderen Vorteil in Bezug auf komplexe Übermittlungen in heterogenen Umgebungen aus.
REST steht für REpresentational State Transfer und beschreibt ein Architekturmodell, dass man täglich an vielen Stellen des WWW, seinem logischen Vorbild, wiederfindet. Während SOAP “nur” ein Transfermedium von Nachrichten ist, hat REST eine konkrete Vorstellung wie mit entsprechenden Schnittstellen umgegangen wird.
Hierfür stehen die klassischen Web-Methoden GET, POST, PUT und DELETE zur Verfügung. Abhängig von Ihrer Verwendung ist somit auch die grundlegende Funktion beschrieben.
Ein Beispiel:

GET http://rest.service.de/hosts/server1/status

Hier ist klar zu erkennen, dass die Ressourcenauflösung über Pfade dazu verwendet wird ein Objekt eindeutig zu identifizieren und den Status zu ermitteln. Soll ein neuer Status hinzugefügt werden, kann das folglich mit einem POST-Request erfolgen. Die Ausgabe des REST-Kommandos ist im Vergleich zu SOAP nicht im Detail spezifiziert, jedoch wird häufig XML verwendet, da sich die Weiterverarbeitung deutlich einfacher gestaltet. Über den Verweis auf anderer REST-Ressourcen mit Hilfe der sogenannten XLinks’s können auch hierarchische Beziehungen abgebildet und aufgelöst werden.
In dieser Einfachheit liegt der klare Vorteil von REST, da sich der Entwickler, mit Ausnahme der strukturierten Verzeichnisauflösung, an keine definierten Übertragungsformate halten muss und die Anwendung leichtgewichtig gestalten kann. Daraus ergibt sich jedoch auch eine stark verzahnte Kommunikationsebene zwischen Client und Server, da der Spezifikation kein Routingmodell hinterlegt ist.
Die Entscheidung für SOAP oder REST ist, wie bereits im vorhergehenden Artikel erläutert, abhängig vom Bedarf an Komplexität und der Möglichkeit komplexere Transaktionen zu bündeln und zu routen. Der überwiegende Teil an Systemen wird jedoch leicht mit REST auskommen und von den agilen Möglichkeiten profitieren.

Bernd Erk
Bernd Erk
CEO

Bernd ist Geschäftsführer der NETWAYS Gruppe und verantwortet die Strategie und das Tagesgeschäft. Bei NETWAYS kümmert er sich eigentlich um alles, was andere nicht machen wollen oder können (meistens eher wollen). Darüber hinaus startet er das wöchentliche Lexware-Backup und investiert seine ganze Energie in den Rest der Truppe und versucht für kollektives Glück zu sorgen. In seiner Freizeit macht er mit sinnlosen Ideen seine Frau verrückt und verbündet sich dafür mit seinem Sohn.

Architekturstile: SOAP

Wie vor einigen Wochen versprochen, möchte ich heute einmal auf das SOAP-Protokoll eingehen. SOAP steht für Simple Object Access Protocol, besser gesagt stand. Seit den letzteren Versionen hat man dieses Akronym aufgrund der hohen Komplexität, die zugegeben mit Simple nicht viel zu tun hat, aufgegeben.
Als Protokoll beschreibt SOAP unter Nutzung von XML eher den Aufbau einer Nachricht als die eigentliche Übertragung. Eine SOAP-Nachricht besteht aus einer Hülle, dem so genannten SOAP-Envelop und beinhaltet einen entsprechenden Header und Body. Während der SOAP-Header optional ist, muss der Body ausgeführt sein und kann noch ein entsprechendes SOAP-Fault Element enthalten um Fehlersituationen zu übermitteln.
Ein Beispiel für eine gültige SOAP-Nachricht:

<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
<soap:Body xmlns:m="http://www.icinga.org/status">
  <m:GetStatus>
    <m:ServerStatus>srv-lin-01</m:StockName>
  </m:GetStatus>
</soap:Body>
</soap:Envelope>

Zwar ist HTTP oder HTTPS der häufigste Standard um entsprechende Nachrichten zu übermitteln, es ist jedoch auch eine alternative Nutzung von JMS, SMTP oder anderen Transportmodellen möglich.
Im Unterschied zu REST, dazu bald mehr, ist SOAP kein leichtgewichtiges Unterfangen. Es Bedarf wohl definierten Schnittstellen und Namespaces um sich bei verschiedenen Services in größeren Umgebungen nicht in die Quere zu kommen und ist aufgrund des entsprechenden XML-Overheads bei der Übertragung von großen Datenmengen nicht besonders performant. Diese Nachteile verlieren durch immer größere Bandbreiten und entsprechende Performance jedoch zunehmend an Bedeutung und auch die entsprechende XML-Parser haben in Sachen Geschwindigkeit ordentlich zugelegt.
Der große Vorteil von SOAP liegt darin, dass ein entsprechender Service genau auf die Beantwortung bestimmter Requests vorbereitet werden muss und somit schon auf Schnittstellenebene gewisse Unstimmigkeiten eliminiert werden können. Ein “ungefähr” Request wird freundlich vom Server zurückgewiesen und vermeidet eine fehlerhafte Verarbeitung auf Definitionsebene.
Die beliebige Komplexität eines SOAP-Envelops ermöglicht jedoch die Zusammenfassung komplexer Transaktionen und Strukturen in einer Nachricht. So kann der Overhead der Einzelabfrage reduziert werden und komplexe Zusammenhänge einfacher dargestellt werden als durch Abbildung einer Vielzahl von REST-Requests.
Eine Entscheidung zugunsten von SOAP sollte nur bei Notwendigkeit der entsprechenden Komplexität fallen, ist dann aber oft auch sinnvoll.
Handle with Care!

Bernd Erk
Bernd Erk
CEO

Bernd ist Geschäftsführer der NETWAYS Gruppe und verantwortet die Strategie und das Tagesgeschäft. Bei NETWAYS kümmert er sich eigentlich um alles, was andere nicht machen wollen oder können (meistens eher wollen). Darüber hinaus startet er das wöchentliche Lexware-Backup und investiert seine ganze Energie in den Rest der Truppe und versucht für kollektives Glück zu sorgen. In seiner Freizeit macht er mit sinnlosen Ideen seine Frau verrückt und verbündet sich dafür mit seinem Sohn.

Weekly Snap: Heatmap for Icinga, JIT cool, Windows 2000 and SOAP/REST?

14 – 18 June warned Windows 2000 users of looming support freezes, gawked in awe at JIT, shared Julian’s LinuxTag presentation, introduced the SOAP and REST developer conflict and announced our first Icinga addon.
Reflecting on hot summer days in data centers, Jannis revealed Heatmap for Icinga. Now while enjoying ice cream, admins can view their server room and react quickly to temperature problems. With a drag and drop, servers and sensors can be laid out on the map and intervals for temperature processing set. Replete with dashboard, it integrates seamlessly into Icinga Web and is ready for download at netways.org as always.
We paid our respects to JIT (JavaScript InfoVis Toolkit) while Julian shared his presentation slides from LinuxTag in Berlin on Nagios and Icinga. He then went on to bring bad news to Windows 2000 users – as of 13 July 2010, Microsoft will end support for all Windows 2000 regardless of type. This means no free updates or security updates, which may also mean security problems will no longer be fixed. On the same day, normal support for Windows 2003 Server (and Server R2) will run out and only extended support will be provided. So only issues critical to security will be fixed, for all others a patch will be offered only to those in their paid support program. This extended support will be available to 14 July 2015- so it seems now is high time to switch out!
Finally, Bernd introduced his new series to tackle the SOAP or REST question which all developers inevitably face in service oriented development. He plans to look at both architectures in detail and compare their advantages and disadvantages. In the meantime he pointed to a previous post from Julian for a good starting point. Till then, keep your eyes peeled!

SOAP oder REST: Was ist los?

Im Bereich der serviceorientierten Entwicklung steht der Developer häufig zu Beginn vor der entscheidenden Frage:
SOAP oder REST
Gleich vorweggenommen sei die Tatsache, dass auch diese kleine Serie keine universelle Antwort auf eine solche Frage geben kann. Es ist vielmehr der Versuch etwas Licht ins Dunkle zu bringen und die Vorteile beider Möglichkeiten zu erörtern. Letztendlich geht es wie immer um die richtig Lösung für die vorhandene Aufgabenstellung und vorhandenem Knowhow.
Grundsätzlich trifft es das Bild von Julian’s Blog Post ganz gut, jedoch ist die Tatsache das wenig “gesprochen” wird nicht nur ein Vorteil.
Die nächsten Tage werde ich auf beide Architekturmodelle etwas detaillierter eingehen und deren Vor- und Nachteile erörtern.

(via Geek And Poke)

Bernd Erk
Bernd Erk
CEO

Bernd ist Geschäftsführer der NETWAYS Gruppe und verantwortet die Strategie und das Tagesgeschäft. Bei NETWAYS kümmert er sich eigentlich um alles, was andere nicht machen wollen oder können (meistens eher wollen). Darüber hinaus startet er das wöchentliche Lexware-Backup und investiert seine ganze Energie in den Rest der Truppe und versucht für kollektives Glück zu sorgen. In seiner Freizeit macht er mit sinnlosen Ideen seine Frau verrückt und verbündet sich dafür mit seinem Sohn.