Was sind Microservices?

Microservices sind ein Architekturstil, bei dem eine Anwendung nicht als ein großes, monolithisches System entwickelt wird, sondern aus vielen kleinen, voneinander unabhängigen Diensten besteht. Jeder dieser Services erfüllt eine klar abgegrenzte Aufgabe – zum Beispiel Benutzermanagement, Zahlungsabwicklung oder Produktsuche – und kommuniziert mit den anderen über klar definierte Schnittstellen (meistens per HTTP/REST oder Messaging).

Vorteile von Microservices

Unabhängigkeit der Teams
Da jeder Service separat entwickelt und bereitgestellt werden kann, können Teams autonom arbeiten, ihre bevorzugten Technologien wählen und Änderungen schneller umsetzen.

Skalierbarkeit
Nicht die ganze Anwendung muss hochskaliert werden – nur die Services, die es wirklich brauchen. So kann zum Beispiel der Suchservice bei Lastspitzen getrennt von anderen Komponenten skaliert werden.

Fehlertoleranz
Ein Fehler in einem Service muss nicht gleich die gesamte Anwendung lahmlegen. Durch geeignete Maßnahmen (z.B. Circuit Breaker, Retry-Strategien) können Microservices robuster werden.

Schnellere Releases
Dank unabhängiger Deployments lassen sich einzelne Komponenten aktualisieren, ohne das ganze System neu auszrollen.

Herausforderungen

Komplexität der Kommunikation
Wo früher einfache Funktionsaufrufe genügten, müssen heute Netzwerkanfragen, Timeouts, Fehlertoleranz und Datenkonsistenz zwischen Services bedacht werden.

Monitoring und Debugging
In einer Microservices-Architektur ist es schwieriger, den Überblick zu behalten. Gute Logging-, Tracing- und Monitoring-Tools sind Pflicht.

Datenmanagement
Jeder Service verwaltet idealerweise seine eigene Datenbank. Dadurch entstehen neue Herausforderungen bei der Konsistenz und bei komplexen Abfragen.

DevOps- und Infrastruktur-Aufwand
Continuous Integration, Deployment, Containerisierung (z.B. Docker), Orchestrierung (z.B. Kubernetes) – wer Microservices ernst meint, muss auch die passende Infrastruktur beherrschen.

Wann lohnt sich der Einsatz?

Microservices sind kein Allheilmittel. Für kleine Teams oder überschaubare Anwendungen kann ein gut strukturierter Monolith die bessere Wahl sein. Der Umstieg darauf lohnt sich vor allem, wenn:

• mehrere Teams gleichzeitig an der Anwendung arbeiten,
• Skalierbarkeit ein zentrales Thema ist,
• einzelne Komponenten sich unterschiedlich schnell entwickeln,
• Continuous Delivery aktiv betrieben wird.

Fazit

Microservices bieten enorme Vorteile in Sachen Flexibilität, Skalierbarkeit und Geschwindigkeit – bringen aber auch mehr Komplexität mit sich. Wer den Schritt wagt, sollte sich der technischen und organisatorischen Anforderungen bewusst sein. Mit einer guten Strategie und den richtigen Tools können Microservices jedoch ein echter Gamechanger sein.

Der Beitrag Microservices – Was steckt hinter dem Architekturtrend? erschien zuerst auf CEOsBay.

Was ist ein Data Transfer Object (DTO)?

Ein DTO ist ein einfaches Objekt, das ausschließlich zur Übertragung von Daten verwendet wird. Es enthält nur Attribute und Getter/Setter-Methoden, aber keine Geschäftslogik. Dadurch wird sichergestellt, dass die Daten in einer standardisierten Form von einer Schicht zur anderen weitergegeben werden können.

Warum DTOs verwenden?

DTOs bieten eine Reihe von Vorteilen, darunter:

1. Kapselung von Daten: Sie ermöglichen eine klare Trennung zwischen der Geschäftslogik und der Datenübertragung.
2. Reduzierung der Datenmenge: DTOs helfen, nur die benötigten Informationen zu übertragen, anstatt vollständige Domänenobjekte zu senden.
3. Verbesserte Sicherheit: Sensible Daten können herausgefiltert werden, bevor sie an externe Systeme gesendet werden.
4. Bessere Wartbarkeit: Änderungen an der internen Datenstruktur haben weniger Einfluss auf externe Schnittstellen.

Implementierung eines DTO

Die Implementierung eines DTOs ist in den meisten objektorientierten Programmiersprachen einfach. Hier ein Beispiel in Java:

public class UserDTO {
    private String name;
    private String email;

    public UserDTO(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

In diesem Beispiel enthält UserDTO nur Datenfelder und Getter/Setter-Methoden. Es repräsentiert eine vereinfachte Benutzerstruktur, die man für die Kommunikation zwischen verschiedenen Komponenten verwenden kann.

DTO in modernen Architekturen

In modernen Softwarearchitekturen wie Microservices oder REST-APIs sind DTOs besonders nützlich. Sie ermöglichen eine gezielte Anpassung der Daten, die man zwischen Client und Server übertragen möchte und tragen zur Optimierung von API-Calls bei.

Ein Beispiel für ein DTO in einer Spring Boot REST API:

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        return new UserDTO(user.getName(), user.getEmail());
    }
}

Hier stellt der UserDTO sicher, dass nur relevante Benutzerdaten an den Client zurückgegeben werden.

Fazit

Data Transfer Objects sind ein wertvolles Muster zur strukturierten und effizienten Datenübertragung. Sie bieten Vorteile hinsichtlich Sicherheit, Effizienz und Wartbarkeit und sind besonders in API-gestützten Systemen unerlässlich. Wer eine saubere und flexible Softwarearchitektur entwickeln möchte, sollte DTOs in seine Strategie einbeziehen.

Der Beitrag Data Transfer Object (DTO) erschien zuerst auf CEOsBay.

Was ist SOA?

Die serviceorientierte Architektur ist ein Ansatz zur Softwareentwicklung, bei dem man Anwendungen als eine Sammlung voneinander unabhängiger Dienste strukturiert. Jeder Dienst bietet eine klar definierte Funktionalität an, die man über standardisierte Schnittstellen ansprechen kann. Diese Dienste sind lose gekoppelt, was bedeutet, dass sie unabhängig voneinander entwickelt, aktualisiert und skaliert werden können.

SOA basiert auf einer Reihe von Prinzipien:

• Lose Kopplung: Dienste sind nicht direkt voneinander abhängig, sondern kommunizieren über definierte Schnittstellen. Siehe auch meinen Beitrag „API – Nahtlose Verbindungen für Innovationen„.
• Wiederverwendbarkeit: Ein einmal entwickelter Dienst kann in verschiedenen Anwendungen oder Prozessen genutzt werden.
• Interoperabilität: Dienste können unabhängig von der zugrunde liegenden Technologie miteinander kommunizieren.
• Modularität: Anwendungen werden in kleinere, eigenständige Einheiten zerlegt.

Vorteile von SOA

SOA bietet eine Reihe von Vorteilen für Unternehmen, insbesondere in komplexen IT-Landschaften:

• Flexibilität: Durch die lose Kopplung der Dienste können Änderungen oder Erweiterungen vorgenommen werden, ohne dass das gesamte System betroffen ist.
• Skalierbarkeit: Einzelne Dienste können unabhängig voneinander skaliert werden, je nach Bedarf.
• Wiederverwendbarkeit: Vorhandene Dienste kann man in neuen Kontexten nutzen, was Entwicklungsaufwand spart.
• Bessere Wartbarkeit: Durch die Modularität der Architektur kann man Fehler schneller beheben und Updates einfacher durchführen.

Herausforderungen und Best Practices

Trotz der zahlreichen Vorteile gibt es einige Herausforderungen bei der Implementierung von SOA:

• Komplexität: Die Verwaltung vieler unabhängiger Dienste kann anspruchsvoll sein.
• Performance: Da Dienste häufig über Netzwerke kommunizieren, kann dies zu Latenzen führen.
• Sicherheit: Die Absicherung der Kommunikation zwischen Diensten ist essenziell, insbesondere in verteilten Systemen.

Um diesen Herausforderungen zu begegnen, sollte man einige Best Practices befolgen:

• Standardisierte Schnittstellen verwenden: APIs sollten gut dokumentiert und standardisiert sein.
• Service-Governance etablieren: Regeln für die Nutzung und Verwaltung von Diensten helfen, Chaos zu vermeiden.
• Monitoring und Logging: Eine gute Überwachung der Dienste ist entscheidend, um Probleme frühzeitig zu erkennen und zu beheben.

SOA vs. Microservices – Ist SOA veraltet?

Viele moderne Entwickler bevorzugen heutzutage Microservices gegenüber SOA, da sie eine noch granularere und flexiblere Architektur bieten. Während SOA oft große, in sich geschlossene Dienste definiert, setzt der Microservices-Ansatz auf sehr kleine, spezialisierte Services, die über leichtgewichtige Protokolle (z.B. REST oder gRPC) kommunizieren.

Einige Unterschiede zwischen SOA und Microservices:

• Granularität: Microservices sind feingranularer als klassische SOA-Dienste.
• Kommunikation: Während SOA häufig auf komplexe Middleware (z.B. Enterprise Service Bus, ESB) setzt, nutzen Microservices oft einfache REST– oder gRPC-Schnittstellen.
• Bereitstellung: Microservices erlauben eine unabhängige Bereitstellung und Skalierung einzelner Services, während SOA eher in größeren Einheiten verwaltet wird.
• Technologievielfalt: Microservices-Architekturen erlauben eine breitere Wahl an Technologien und Programmiersprachen für einzelne Services.

Alternativen zu SOA

Neben Microservices gibt es weitere Architekturansätze, die für verschiedene Szenarien geeignet sein können:

• Monolithische Architektur: Eine traditionelle Architektur, bei der die gesamte Anwendung als eine einzige Einheit entwickelt wird. Dies kann für kleinere Anwendungen sinnvoll sein, ist aber weniger skalierbar.
• Serverless Computing: Dienste werden nur bei Bedarf ausgeführt, was eine kosteneffiziente und skalierbare Alternative darstellt.
• Event-Driven Architecture: Anwendungen bestehen aus lose gekoppelten Komponenten, die auf Events reagieren, was eine hohe Skalierbarkeit ermöglicht.

Fazit

SOA bleibt auch in Zeiten moderner Architekturen ein relevantes Konzept, insbesondere für Unternehmen mit bestehenden monolithischen Systemen. Dennoch gilt es heute als weniger agil (Siehe meinen Beitrag „Agile Manifest – Die bessere Art der Softwareentwicklung„) als Microservices, die mehr Flexibilität und Unabhängigkeit bieten. Abhängig von den Anforderungen eines Unternehmens kann SOA weiterhin eine geeignete Lösung sein, insbesondere wenn man bestehende Systeme integrieren muss. Wer sich jedoch für eine zukunftssichere, hochgradig skalierbare Architektur interessiert, sollte Alternativen wie Microservices oder Serverless-Ansätze in Betracht ziehen.

Der Beitrag SOA (Serviceorientierte Architekturen) erschien zuerst auf CEOsBay.

Grundlagen einer IT-Architektur

Eine IT-Architektur beschreibt die Struktur und das Zusammenspiel von Hardware, Software, Netzwerken und Daten in einem Unternehmen. Sie dient als Blaupause für IT-Systeme und sorgt für Effizienz, Skalierbarkeit und Sicherheit. Es gibt verschiedene Architekturstile, darunter:

• Monolithische Architekturen: Traditionelle, zentralisierte Systeme, die alle Funktionen in einer einzigen Anwendung bündeln.
• Serviceorientierte Architekturen (SOA): Modularisierte Ansätze, bei denen einzelne Dienste über Schnittstellen miteinander kommunizieren.
• Mikroservices-Architekturen: Flexible, verteilte Systeme, bei denen einzelne Komponenten unabhängig voneinander agieren können.

Wichtige Prinzipien moderner IT-Architekturen

Um den steigenden Anforderungen an IT-Systeme gerecht zu werden, setzen Unternehmen auf folgende Prinzipien:

1. Skalierbarkeit: IT-Systeme müssen in der Lage sein, mit steigenden Anforderungen und Datenmengen umzugehen. Cloud-Computing und Container-Technologien (z.B. Docker, Kubernetes) ermöglichen dynamische Skalierung.
2. Flexibilität & Agilität: Durch modulare Strukturen wie Microservices und API-basierte Kommunikation können Unternehmen schnell auf Marktveränderungen reagieren.
3. Sicherheit & Datenschutz: Moderne Architekturen müssen strenge Sicherheitsstandards einhalten. Zero-Trust-Modelle, Verschlüsselung und Identity-Management spielen eine zentrale Rolle.
4. Automatisierung & Orchestrierung: CI/CD-Pipelines, DevOps-Praktiken und Infrastructure-as-Code (IaC) erleichtern das Management und die Bereitstellung von IT-Systemen.

Trends und Zukunft der IT-Architektur

Die IT-Landschaft entwickelt sich rasant weiter. Einige Trends, die die Architektur der Zukunft beeinflussen, sind:

• Edge Computing: Dezentrale Verarbeitung direkt an den Endpunkten reduziert Latenzen und erhöht die Performance.
• Künstliche Intelligenz & Machine Learning: Automatisierte Optimierung von Architekturen, beispielsweise durch Self-Healing-Mechanismen.
• Blockchain & Dezentralisierung: Mehr Transparenz und Sicherheit für verteilte Systeme.
• Serverless Computing: Reduziert den Verwaltungsaufwand für Infrastruktur und steigert die Effizienz.

Fazit

Eine durchdachte IT-Architektur ist essenziell für den Unternehmenserfolg in der digitalen Ära. Skalierbare, sichere und flexible Systeme ermöglichen Innovationen und Wettbewerbsvorteile. Unternehmen, die auf moderne Architekturen setzen, schaffen die Grundlage für eine zukunftssichere IT-Strategie.

Der Beitrag IT-Architektur – Skalierbarkeit, Flexibilität und Sicherheit erschien zuerst auf CEOsBay.

Was ist ALF-LB?

Der Begriff Auxiliary Loss bezieht sich auf zusätzliche Berechnungen oder Overheads, die für die Steuerung und Optimierung des Load Balancing anfallen. Diese können in Form von:

• Monitoring-Kosten,
• Algorithmischen Umverteilungen,
• Synchronisationsverzögerungen oder
• zusätzlichen Kommunikationskosten auftreten.

ALF-LB minimiert diese Verluste durch eine clevere Kombination aus direkter Lastverteilung, adaptiven Algorithmen und latenzoptimierten Entscheidungsprozessen.

Vorteile von Auxiliary-Loss-Free Load Balancing

1. Höhere Effizienz: Da keine Zusatzverluste entstehen, können Ressourcen optimal genutzt werden.
2. Geringere Latenzzeiten: Anfragen werden direkt und ohne zusätzliche Berechnungen an die effizientesten Knoten weitergeleitet.
3. Bessere Skalierbarkeit: Das System kann sich dynamisch an Lastspitzen anpassen, ohne dass komplexe Neuverteilungen notwendig sind.
4. Weniger Overhead: Reduzierung von Monitoring- und Steuerungsprozessen führt zu einer insgesamt besseren Performance.

Technische Umsetzung

Die Implementierung eines Auxiliary-Loss-Free Load Balancers erfolgt häufig durch:

• Dynamische Routing-Algorithmen, die auf Echtzeit-Metriken basieren.
• Predictive Load Distribution, welche die Lastverteilung auf Basis historischer Daten und Machine-Learning–Algorithmen vorausschauend anpasst.
• Dezentralisierte Entscheidungsprozesse, um Engpässe und Synchronisationsverluste zu vermeiden.

Anwendungsfälle

ALF-LB findet Anwendung in zahlreichen Bereichen, darunter:

• Cloud-Computing & Microservices: Optimierung der Ressourcenzuweisung in containerisierten Umgebungen. (Siehe auch meinen Beitrag „Cloud Computing – Skalierbare Ressourcen und grenzenlose Möglichkeiten für agile Lösungen„)
• Content Delivery Networks (CDN): Effiziente Lastverteilung für schnellere Datenbereitstellung.
• Edge Computing: Vermeidung von zentralen Flaschenhälsen durch intelligente Datenverarbeitung am Netzwerkrand.

Beispiel für Auxiliary-Loss-Free Load Balancing

Szenario:

Ein global agierendes E-Commerce-Unternehmen betreibt eine Plattform mit Millionen von Nutzern. Um die Serverlast optimal zu verteilen, wird ein Load-Balancer eingesetzt.

Traditioneller Ansatz mit Auxiliary Loss:

• Der Load-Balancer überwacht kontinuierlich die Serverlast und sammelt Metriken (CPU-Auslastung, Speicher, Antwortzeiten).
• Diese Daten werden verarbeitet, um periodisch die Lastverteilung zu optimieren.
• Das führt zu Verzögerungen und zusätzlichem Rechenaufwand für Monitoring und Entscheidungsfindung.

Auxiliary-Loss-Free Load Balancing:

• Statt komplexe Überwachungsmechanismen zu nutzen, verteilt der Load-Balancer Anfragen direkt basierend auf Echtzeit-Kapazität.
• Algorithmen analysieren eingehende Anfragen dynamisch und dezentral, sodass keine Zusatzverluste durch Steuerung entstehen.
• Durch maschinelles Lernen kann das System wiederkehrende Lastmuster vorhersagen und sich selbstständig optimieren.

Ergebnis:

• Schnellere Verarbeitung von Kundenanfragen ohne Verzögerungen.
• Keine unnötigen Rechen- oder Kommunikationskosten für Monitoring.
• Hohe Skalierbarkeit bei minimalem Overhead.

Fazit

Auxiliary-Loss-Free Load Balancing ist ein vielversprechender Ansatz zur Optimierung der Lastverteilung, insbesondere für skalierbare und hochperformante Systeme. Durch die Reduzierung unnötiger Overheads und eine gezielte Ressourcenallokation lassen sich signifikante Performance-Verbesserungen erzielen. Wer in modernen IT-Architekturen maximale Effizienz erreichen möchte, sollte ALF-LB definitiv in Betracht ziehen.

Der Beitrag Auxiliary-Loss-Free Load Balancing – Effiziente Lastverteilung erschien zuerst auf CEOsBay.

1. Autokonfiguration
2. Ein Opinionated-Konfigurationsansatz
3. Die Fähigkeit, eigenständige Anwendungen zu erstellen

Das Zusammenspiel dieser Funktionen ermöglicht die Installation einer Spring basierten Anwendung mit minimalem Konfigurations- bzw. Einrichtungsaufwand, worauf ich nachfolgend näher eingehe. Mit einem breiten Spektrum an Funktionalitäten ist es eine ganzheitliche Lösung, wobei die Entkopplung der Applikationskomponenten im Vordergrund steht.

Was ist das Spring Framework und was stellt Spring Boot damit an?

Ein Spring Framework bietet eine Abhängigkeitsinjektionsfunktion, mit der Objekte ihre eigenen Abhängigkeiten definieren können.Der Spring-Container injiziert diese nachfolgend. So kann man als Entwickler modulare Anwendungen erstellen, die aus losen verbundenen Komponenten bestehen. Diese eignen sich ideal für Microservices und verteilte Netzanwendungen.

Das Spring Framework bietet auch die integrierte Unterstützung für typische Aufgaben, die eine Anwendung ausführen muss. Beispiele hierfür sind Datenbindung, Typumsetzung, Prüfung und Bewertung, Ausnahmebehandlung, Ressourcen- und Ereignismanagement und vielem mehr. Darüber hinaus lässt es sich mit verschiedenen Java EE-Technologien wie RMI (Remote Method Invocation), AMQP (Advanced Message Queuing Protocol), Java Web Services und anderen integrieren. Alles in allem liefert das Spring Framework Entwicklern alle Tools und Funktionen, die man benötigt, um lose verbundene, plattformunabhängige Java EE-Anwendungen zu erstellen, die man in den verschiedensten Umgebungen ausführen kann. So leistungsfähig und umfassend das Spring Framework auch ist, so viel Zeit und Know-How erfordert es, Spring-Anwendungen sauber zu konfigurieren, einzurichten und bereitzustellen. Spring Boot verringert diesen Aufwand mit den bereits zu Beginn erwähnten drei wichtigen Funktionen.

Autokonfiguration in Spring Boot

Unter der Autokonfiguration verstehen man die Initialisierung von Anwendungen mit voreingestellten Abhängigkeiten ohne den manuellen Eingriff eines Entwicklers. Da Java Spring Boot über integrierte Autokonfigurationsfunktionen verfügt, konfiguriert es sowohl das zugrunde liegende Spring Framework als auch die Pakete von Drittanbietern automatisch auf der Grundlage der eigenen individuellen Einstellungen. Dies trägt auch zur grundlegenden Fehlervermeidung bei. Auch wenn man die Standardeinstellungen nach Abschluss der Initialisierung überschreiben kann, ermöglicht die Autokonfigurationsfunktion von Java Spring Boot einen schnellen Start bei der Entwicklung von Spring-basierten Anwendungen. Dies reduziert die Möglichkeit menschlicher Fehler.

Opinionated-Konfigurationsansatz

Der Optionated-Ansatz bei Spring Boot findet Anwendung beim Hinzufügen und bei der Konfiguration von Steuer-Abhängigkeiten, basierend auf den Projektanforderungen. Spring Boot wählt nach eigenem Ermessen die passenden Pakete zur Installation aus und setzt auch die Standardwerte, ohne dass ein nachträgliches manuelles Eingreifen erforderlich ist.

Man kann die Anforderungen des jeweiligen Projekts während des Initialisierungsprozesses definieren. Dabei wählt man zwischen mehreren Starter-Abhängigkeiten (den Spring Starters) die typische Anwendungsfälle abdecken. Man startet den Spring Boot Initializr (Das ist kein Rechtschreibfehler 😉 ), indem man ein einfaches Webformular ausfüllt. Alles erst einmal ohne zu programmieren und ohne Code.

Mit der Starter-Abhängigkeit „Spring Web“ kann man beispielsweise Spring-basierte Webanwendungen mit minimaler Konfiguration erstellen, indem man im Projekt alle erforderlichen Abhängigkeiten – wie den Apache Tomcat Webserver – hinzufügt. „Spring Security“ ist eine weitere vielfach eingesetzte Starter-Abhängigkeit, die automatisch Authentifizierungs- und Zugriffskontrollfunktionen zur Verfügung stelllt. Spring Boot enthält von Haus aus über 50 Spring-Starter, und viele weitere Starter von Drittanbietern sind ebenfalls verfügbar.

Eigenständige Anwendungen

Spring Boot hilft Entwicklern, Anwendungen zu erstellen, die einfach funktionieren. Insbesondere kann man damit eigenständige Anwendungen erstellen, die ohne einen externen Webserver auskommen, indem man einen Webserver wie Tomcat oder Netty während des Initialisierungsprozesses in der eigenen Anwendung einbettet. So kann man die Anwendung auf jeder Plattform starten, indem man einfach auf den Befehl „Ausführen“ klickt. Man kann aber auch auf diese Funktion verzichten, indem man dies in der Konfiguration deaktiviert.

Fazit

In der Praxis ist die Verwendung von Spring Boot durchaus zu empfehlen. Außer man hat vor, eine sehr spezielle Konfiguration zu implementieren. Man kann weiterhin das vielfach eingesetzte Annotationssystem von Spring Framework verwenden, mit dem man auf einfache Weise zusätzliche Abhängigkeiten (deren Abdeckung nicht von Spring Starters gewährleistet ist) in die Anwendung implementieren kann. Auch hat man weiterhin Zugriff auf alle Spring Framework-Funktionen, einschließlich der einfachen Ereignisverarbeitung, Prüfung und Bewertung, Datenbindung, Typumsetzung und der integrierten Sicherheits- und Testfunktionen. Kurz zusammengefasst – Wenn die Abdeckung des Projektumfangs lediglich ein Spring Starter gewährleistet, kann Spring Boot die Entwicklung signifikant rationalisieren.

Der Beitrag Spring Boot – Schnell und einfach Webanwendungen erstellen erschien zuerst auf CEOsBay.

Kurze Zeitreise

Jenkins ist in erster Linie eine Entwicklung von Kohsuke Kawaguchi. Einem ehemaligen Mitarbeiter von Sun Microsystems, der es unter dem Namen Hudson entwickelt hat. Kawaguchi verließ das Unternehmen, nachdem Oracle es Ende Januar 2010 übernahm. Er behielt aber die Leitung bei Hudson und arbeitete nach eigenen Angaben auf freiberuflicher Basis weiter bei Oracle. Oracle hielt nach wie vor die Namensrechte an Hudson. Aus diesem Grund hat man das Projekt schließlich in Jenkins umbenannt. Die Namensgebung erfolgte laut der Entwickler aufgrund der äquivalenten Assoziation der beiden Wörter mit dem Beruf des Butlers.

Oracle trieb die Entwicklung von Hudson weiterhin voran. Deshalb spricht man heute von einem Fork (einer „Abspaltung“) in der Softwareentwicklung. Im Jahr 2016 wurde die Entwicklung von Hudson zugunsten von Jenkins eingestellt und der Eclipse Foundation gespendet. Die Entwicklung wird jetzt als Open-Source-Projekt unter der Leitung der CD Foundation, einer Organisation innerhalb der Linux Foundation, verwaltet.

Wofür Pipelines?

Im Grunde genommen automatisieren Pipelines Tests und Berichte zu isolierten Änderungen in einer größeren Codebasis in Echtzeit und erleichtern die Integration unterschiedlicher Codezweige in einen Hauptzweig. Man erkennt dadurch schnell Fehler in einer Codebasis, erstellt die Software, automatisiert das Testen der Builds, bereitet die Codebasis für die Bereitstellung (Auslieferung) vor und stellt schließlich Code in Containern und auf virtuellen Maschinen sowie Bare-Metal- und Cloud-Servern bereit. Es gibt auch kommerzielle Versionen von Jenkins, auf die ich in diesem Beitrag aber nicht weiter eingehe.

Continious Integration / Kontinuierliche Integration

Kontinuierliche Integration hat sich seit der Erfindung weiterentwickelt. Ursprünglich war es die Norm, dass Teams einen Build pro Tag veröffentlichten. Nun ist es die Regel, dass jedes Teammitglied täglich oder häufiger Aktualisierungen einreicht, die man als Commit bezeichnet (Siehe Git / GitHub). Dies erfolgt bei jeder wesentlichen Änderung eines Builds. Bei der richtigen Anwendung bietet Continuous Integration verschiedene Vorteile, wie zum Beispiel ständige Rückmeldungen zum Status der Software. Da man durch CI, Mängel frühzeitig in der Entwicklung erkennt, sind Fehler in der Regel kleiner, weniger komplex und leichter zu beheben.

Jenkins und CI/CD

Im Laufe der Zeit wurden Jenkins Continuous Delivery und Deployment hinzugefügt. Continuous Delivery bedeutet, dass das Erstellen und Packen von Code für die spätere Bereitstellung in Test-, Produktions-Staging- und Produktionsumgebungen automatisiert wird. Continuous Deployment automatisiert den letzten Schritt der Bereitstellung des Codes an seinem endgültigen Ziel.

In beiden Fällen reduziert die Automatisierung die Anzahl der auftretenden Fehler, da die richtigen Schritte und Best Practices in Jenkins kodiert sind. Jenkins beschreibt einen gewünschten Zustand und der Automatisierungsserver stellt sicher, dass dieser Zustand erreicht wird. Darüber hinaus macht diese Automatisierung die Bereitstellung schneller, da Vorgänge nicht mehr an personelle Beschränkungen gebunden sind. Schließlich reduziert es die Belastung des Entwicklungs- und Betriebsteams, indem es die Notwendigkeit von manuellen Rollouts mitten in der Nacht und am Wochenende beseitigt.

Jenkins und Microservices

Jenkins bewährt sich besonders in Microservices-Architekturen. Da es eines der Ziele von Microservices ist, Anwendungen und Dienste häufig zu aktualisieren, sollte man dafür sorgen, dass die Bandbreite die Releases nicht verzögert. Mehr und kleinere Dienste mit schnelleren Update-Intervallen lassen sich nur durch Automatisierung gut umsetzen – und dafür ist es wohl die richtige Wahl.

Jenkins X

Das Jenkins X-Projekt wurde 2018 mit dem Ziel gestartet, eine moderne, Cloud-native Version von Jenkins zu erschaffen. Das Projekt steht ebenfalls unter der Leitung der CD Foundation. Die Architektur, Technologie und Pipeline-Sprache unterscheiden sich grundsätzlich von Jenkins. Jenkins X ist für Kubernetes konzipiert und verwendet es in einer eigenen Implementierung. Andere Cloud-native Technologien, die Jenkins X verwendet, sind Helm und Tekton, auf die ich in gesonderten Beiträgen eingehen werde.

Wie funktioniert Jenkins?

Jenkins läuft auf einer Vielzahl von Betriebssystemen bzw. Plattformen. Darunter gibt es Windows, MacOS und Unix-Varianten. Am besten jedoch läuft es auf Linux. Es erfordert mindestens eine Java 8 VM oder höher und kann auf Oracle Java Runtime Environment oder Open Java Development Kit ausgeführt werden. Normalerweise läuft es als Java-Servlet innerhalb eines Jetty-Anwendungsservers. Es kann aber auch auf anderen Java-Anwendungsservern wie Apache Tomcat ausgeführt werden. Auch kann es in einem Docker-Container ausgeführt werden. Im Docker Hub-Online-Repository sind aus diesem Grund schreibgeschützte Jenkins-Images verfügbar.

Um Jenkins zu auszuführen, werden Pipelines erstellt. Eine Pipeline ist eine Reihe von Schritten, die der Jenkins-Server ausführt. Diese Schritte sind in einem Klartext-Jenkins-File gespeichert. Das Jenkins-File verwendet eine geschweifte Klammersyntax, die einer JSON gleicht. Schritte in der Pipeline werden als Befehle mit Parametern deklariert und in geschweiften Klammern gekapselt. Der Jenkins-Server liest dann die Jenkins-Datei und führt die Befehle aus, wobei der Code die Pipeline vom festgeschriebenen Quellcode zur Produktionslaufzeit weiterleitet. Ein Jenkins-File kann über eine grafische Benutzeroberfläche oder durch Code erstellt werden.

Plugins

Für Jenkins sind eine Reihe von Plugins verfügbar, damit es mit anderen Tools zusammenarbeiten kann. Mit Plugins lässt sich auch der Funktionsumfang der Software erweitern. Fertige bzw. bewährte Plugins können aus dem Online-Repository für Jenkins-PlugIns heruntergeladen und über die Jenkins-Webbenutzeroberfläche oder -CLI (Kommandozeile, Command Line Interface) geladen werden. Man kann aber auch eigene Plugins entwickeln.

Plugins helfen bei der Integration anderer Entwicklertools in die Jenkins-Umgebung, fügen der Web-UI neue Elemente hinzu. Dies dient im Allgemeinen der erleichterten Verwaltung und Benutzung. Ein wichtiges Einsatzgebiet von Plugins ist das Bereitstellen von Integrationspunkten für CI/CD-Quellen und -Ziele. Dazu gehören Software-Versionskontrollsysteme (SVCs) wie Git und Atlassian BitBucket, Container-Laufzeitsysteme – insbesondere Docker, sowie Hypervisoren wie VMware vSphere, Public-Cloud-Instanzen wie Google Cloud Platform und AWS und schließlich Private-Cloud-Systeme wie OpenStack. Es gibt auch Plugins, die eine Kommunikation mit Betriebssystemen über FTP, CIFS und SSH unterstützen.

Plugins verwenden ihren eigenen Satz von Java-Annotationen und Designmustern, die definieren, wie sie instanziiert werden. Die Plugin-Entwicklung nutzt außerdem die Maven-Bereitstellung für Jenkins.

Sicherheit

Bei der Sicherheit geht es vor allem darum den Server und die Benutzer zu schützen. Die Serversicherheit wird mehr oder weniger auf dieselbe Art und Weise erreicht, wie auf regulären Servern. Der Zugriff auf den Standort, beispielsweise eine VM oder einen Bare-Metal-Server, ist so konfiguriert, dass möglichst wenige Prozesse mit dem Server kommunizieren dürfen. Dies wird durch typische Serverbetriebssysteme und Netzwerksicherheitsfunktionen erreicht.

Darüber hinaus ist der Zugriff auf den Server über die Jenkins-Benutzeroberfläche mit den regulären Mechanismen, wie Multi-Faktor-Authentifizierung oder der Beschränkung der Anzahl von legitimierten Benutzern, geschützt.

Jenkins enthält außerdem Sicherheitsfunktionen für die interne Nutzerdatenbank. Man unterscheidet zwei Sicherheitsbereiche. Zum einen den Sicherheitsbereich und den Autorisierungsbereich. Im Sicherheitsbereich regeln Administratoren, wer Zugriff hat, und im Autorisierungsbereich bestimmen die Nutzer selbst, was man mit dem Zugriff anstellen kann.

Fazit

Ein großer Vorteil von Jenkins sind die Unmengen an verfügbaren Plugins. Diese tragen zu einer enormen Flexibilität bei. Auch die umfangreichen Skript- und deklarativen Sprachen, mit denen man stark benutzerdefinierte Pipelines erstellen kann, stellen einen großen Mehrwert dar. Da es weitestgehend neutral ist, passt es gut in die meisten Umgebungen, einschließlich in komplexe Hybrid- und Multi-Cloud-Systeme.

Da Jenkins schon etwas länger als vergleichbare Lösungen in diesem Bereich verwendet wird, gibt es umfangreiche Dokumentationen und zahlreiche Community-Ressourcen, an denen man sich bedienen kann. Diese Ressourcen erleichtern die Installation, Verwaltung und Fehlerbehebung ungemein.

Da die gesamte Lösung auf Java basiert, steht es auf einer soliden Basis, die man mit gängigen Designmustern und Frameworks erweitern kann. Auch wenn sich die Installation relativ einfach gestaltet, kann es relativ schwierig sein, komplexe Pipelines zu entwickeln, zu debuggen und zu warten.

Das Open-Source-System ist außerdem eine Single-Server-Architektur. Dies kann jedoch die Ressourcen auf einen einzigen Computer, eine virtuelle Maschine oder einen Container einschränken. Cluster werden nicht unterstützt. Diese Tatsache kann die Leistung enorm einschränkten. Es kann auch dazu führen, dass es zum Server-Sprawl kommt und man den Überblick über all die einzelnen Jenkins-Server verliert.

Der Beitrag Jenkins – Automatisierte Arbeitsabläufe beim Testing erschien zuerst auf CEOsBay.