Kaffeepause Nr. 120. Java-Operatoren &, && (AND) || (ODER). Einführung in GitOps und DevOps für Entwickler

Java-Operatoren &, && (AND) || (ODER)

Quelle: freeCodeCamp In der Programmiersprache Java verwenden wir Operatoren, um Operationen an Variablen durchzuführen. Operatoren werden in verschiedene Kategorien unterteilt: arithmetische Operatoren, Zuweisungsoperatoren, Vergleichsoperatoren, logische Operatoren usw. In diesem Artikel werden wir über den bitweisen AND-Operator ( & ) sowie die logischen Operatoren AND ( && ) und OR ( || ) sprechen.

So verwenden Sie den bitweisen UND-Operator

Das Symbol & bezeichnet den bitweisen UND-Operator. Es wertet den Binärwert gegebener Zahlen aus. Das binäre Ergebnis dieser Zahlen wird uns in Basis 10 zurückgegeben. Wenn der & -Operator seine Arbeit beginnt, wertet er den Wert der Zeichen in beiden Zahlen aus, beginnend von links. Schauen wir uns ein Beispiel an, um dies besser zu verstehen:

System.out.println(10 & 12);
// returns 8

Wie ist das zu erklären? Der Binärwert von 10 ist 1010. Der Binärwert von 12 ist 1100. Folgendes müssen wir berücksichtigen, bevor wir mit der Operation beginnen: 1 und 0 => 0 0 und 1 => 0 1 und 1 => 1 0 und 0 = > 0 Also lasst uns die Operation durchführen. Das erste Symbol für 10 ist 1, das erste Symbol für 12 ist ebenfalls 1, also: 1 und 1 = 1. Weiter zu den zweiten Symbolen – 0 für 10 und 1 für 12: 1 und 0 = 0. Für die dritten Symbole - 1 für 10 und 0 für 12: 1 und 0 = 0. Für die vierten Zeichen - 0 für 10 und 0 für 12: 0 und 0 = 0. Nun kombinieren wir alle zurückgegebenen Zeichen. Das ergibt 1000. Der Binärwert von 1000 zur Basis 10 ist 8, also hat unsere Operation 8 zurückgegeben.

So verwenden Sie den logischen UND-Operator

Beachten Sie, dass wir boolesche Operatoren verwenden, um Bedingungen auszuwerten. Abhängig von den gegebenen Bedingungen geben sie „true“ oder „false“ zurück. Das &&- Symbol stellt den UND-Operator dar. Es wertet zwei Anweisungen/Bedingungen aus und gibt nur dann „true“ zurück , wenn beide Anweisungen/Bedingungen wahr sind. So sieht seine Syntax aus:

statment1/condition1 && statemnt2/condition2

Wie Sie oben sehen können, gibt es zwei Anweisungen/Bedingungen, die durch eine Anweisung getrennt sind. Der Operator wertet den Wert beider Aussagen/Bedingungen aus und gibt uns das Ergebnis – wahr oder falsch . Hier ist ein Beispiel:

System.out.println((10 > 2) && (8 > 4));
//true

Die Operation gibt true zurück , da beide Bedingungen wahr sind: 10 ist größer als 2 und 8 ist größer als 4. Wenn eine der Bedingungen eine falsche Logik hätte, würden wir false erhalten . Um den &&- Operator besser zu verstehen , sollten Sie wissen, dass beide Bedingungen wahr sein müssen, um als wahr ausgewertet zu werden . Hier ist ein weiteres Beispiel, das false zurückgibt :

System.out.println((2 > 10) && (8 > 4));
// false

Hier ist 2 nicht größer als 10 und 8 ist größer als 4 – wir erhalten also false . Dies liegt daran, dass eine der Bedingungen falsch ist.

• Wenn beide Bedingungen wahr sind => wahr

• Wenn eine der beiden Bedingungen falsch ist => falsch

• Wenn beide Bedingungen falsch sind => falsch

So verwenden Sie den Booleschen OR-Operator

Zur Bezeichnung des OR-Operators verwenden wir das Symbol || . Dieser Operator gibt nur dann false zurück , wenn beide Bedingungen falsch sind. Das heißt, wenn beide Bedingungen wahr sind, erhalten wir wahr , und wenn eine der beiden Bedingungen wahr ist, erhalten wir auch wahr . Hier ist die Syntax:

statment1/condition1 || statemnt2/condition2

Schauen wir uns ein paar Beispiele an.

System.out.println((6 < 1) || (4 > 2));
// true

True wird an uns zurückgegeben , weil eine der Bedingungen wahr ist.

• Wenn beide Bedingungen wahr sind => wahr

• Wenn eine der Bedingungen wahr ist => wahr

• Wenn beide Bedingungen falsch sind => falsch

Abschluss

In diesem Artikel haben wir gelernt, wie man den bitweisen & -Operator und die logischen Operatoren && und || in Java verwendet. . Wir haben auch erfahren, welchen Wert jede Operation abhängig von ihren Bedingungen zurückgibt.

Einführung in GitOps und DevOps für Entwickler

Quelle: Hackernoon Eines der Hauptziele von DevOps besteht darin, Entwicklern dabei zu helfen, eine Funktion so schnell und sicher wie möglich in der Produktion bereitzustellen. Das bedeutet die Schaffung von Tools und Prozessen, die von der Bereitstellung privater Entwicklungsumgebungen bis hin zur Bereitstellung und Sicherung von Produktions-Workloads alles bieten. Gleichzeitig sollte Eile nicht zu kritischen Ausfällen führen. GitOps ist eine Möglichkeit, DevOps zu automatisieren. Genauer gesagt handelt es sich um eine Automatisierungstaktik mithilfe des Git-Entwicklungstools. Da Entwickler bereits Code in ein zentrales Git-Repository übertragen (mit etwas wie GitHub, GitLab oder BitBucket), können DevOps-Entwickler jedes ihrer Arbeitsskripts einbinden, um Anwendungen zu erstellen, zu testen oder bereitzustellen, die nach jeder Codeänderung ausgeführt werden. Dies bedeutet, dass Entwickler ausschließlich mit Git arbeiten können und alles, was ihnen hilft, ihren Code in die Produktion zu bringen, automatisiert wird.

Warum GitOps?

Früher waren DevOps- und CI/CD-Methoden eine Reihe proprietärer Skripte und Tools, die alltägliche Aufgaben erledigten: Tests ausführen, Infrastruktur bereitstellen oder eine Anwendung bereitstellen. Allerdings erfordert die Verfügbarkeit neuer Infrastrukturtools wie Kubernetes in Verbindung mit dem Aufkommen von Microservice-Architekturen eine stärkere Einbindung von Entwicklern in CI/CD-Prozesse. Diese Änderung führte zu Problemen im Zusammenhang mit Benutzerszenarien, was zu verwirrenden und inkonsistenten Arbeitsabläufen, Doppelarbeit und einem starken Rückgang der Entwicklungsgeschwindigkeit führte. Um die Vorteile von Cloud-Tools und -Architekturen nutzen zu können, benötigen Teams einen konsistenten, automatisierten Ansatz für CI/CD. Dadurch können Entwickler:

• Hören Sie auf, proprietäre Skripte zu erstellen und zu pflegen, und nutzen Sie stattdessen einen universellen Prozess.

• Erstellen Sie Apps und Dienste schneller mit einem spezifizierten, universellen Bereitstellungsprozess.

• Schnellere Bereitstellung nach Codeänderungen.

• Ermöglichen Sie die automatisierte Bereitstellung für schnellere, häufigere und zuverlässigere Releases.

• Führen Sie Rollbacks und Audits zur Einhaltung deklarativer Entwurfsmuster durch.

Entwickler lieben GitOps

Aus all den oben genannten Gründen (und vielen weiteren) benötigen Unternehmen verwaltete und automatisierte Ansätze für CI/CD und DevOps, um bei der Erstellung und Wartung von Cloud-Anwendungen erfolgreich zu sein. Aber wenn es nur um Automatisierung geht, warum ist GitOps dann besser als andere Strategien (wie SlackOps, geplante Bereitstellungen oder einfache Skripte)? Die Antwort ist einfach: Entwickler lieben GitOps.

Git – ein Tool, um alles zu verwalten

In den letzten Jahren hat sich gezeigt, dass GitOps unter Entwicklern eine der am höchsten bewerteten DevOps-Automatisierungsstrategien ist, und es ist nicht schwer zu verstehen, warum. Entwickler leben in Git. Sie speichern temporäre Änderungen in Git, arbeiten mit Git zusammen, überprüfen Code mit Git und führen einen Verlauf und ein Audit-Trail aller jemals vorgenommenen Änderungen, auch in Git. Da sich Entwickler so stark auf Git verlassen, stehen spezielle Tools für die Arbeit damit zur Verfügung. In modernen kontinuierlichen Integrationssystemen, die am häufigsten zur Unterstützung von GitOps verwendet werden, wie CircleCI , Github Actions , Gitlab CI und anderen, befinden sich die Konfigurationen, die Pipelines unterstützen, direkt im Git-Repository. Wie der Quellcode der Anwendung unterliegen diese Konfigurationen einer Versionskontrolle und sind für jeden Entwickler sichtbar, der am Projekt arbeitet. Sie können nicht nur den Pipeline-Prozess sehen, sondern bei Bedarf auch schnell und einfach Änderungen daran vornehmen. Dieser einfache Zugriff für Entwickler ist von entscheidender Bedeutung, da sie Tests für ihre Anwendungen schreiben und deren Sicherheit und Stabilität gewährleisten.

Vollständige Selbstbedienung

Neue Funktionen oder Fehlerbehebungen gelten erst dann als abgeschlossen, wenn sie für die Produktion freigegeben werden. Das bedeutet, dass alles, was verhindert, dass Codeänderungen in der Produktion vorgenommen werden, Zeit und Energie des Entwicklers verschwendet. Angenommen, ein Entwickler muss einige Zeit warten, bis ein anderes Team oder eine andere Person eine Aufgabe erledigt hat, bevor er seinen Arbeitsschritt abschließen kann. Dies kann zu Spannungen und Konflikten in der Organisation führen. Die Erleichterung der Zusammenarbeit zwischen Teams ist einer der Hauptvorteile von GitOps. Entwickler erhalten nicht nur die Möglichkeit, mit einem vertrauten Tool zu arbeiten, sondern können ihren Code auch ohne manuelle Eingriffe in die Produktion überführen. Das bedeutet, dass sie nicht darauf warten, dass jemand anderes ihre Aufgaben erledigt.

Kontinuierliche Arbeit in allem

Ein weiterer großer Vorteil von GitOps ist, dass alle Prozesse immer laufen! Jede von uns vorgenommene Änderung löst Test-Builds und -Bereitstellungen aus, ohne dass manuelle Schritte erforderlich sind. Da Entwickler Git mit oder ohne GitOps verwenden, ist die Verbindung mit ihrem vorhandenen Workflow zur Ausführung von DevOps-Prozessen eine ideale Option für die Automatisierung.

GitOps in der Praxis

Natürlich hat die Einbindung von Entwicklern in den Prozess dazu geführt, dass Teams in großem Umfang benutzerfreundliche Tools wie Git nutzen. Dadurch entsteht auch eine natürliche Konsistenz für die Integrations-/Bereitstellungsphasen von CI/CD. Schließlich sind in einem Git-Repository nur eine begrenzte Menge an Dingen verfügbar (z. B. Commits, Open/Close-Pull-Requests, Zusammenführungen usw.), sodass das Erscheinungsbild der meisten GitOps-Implementierungen eine Reihe typischer Schritte umfasst:

1. Pull-Requests, Tests und Vorschauumgebungen

Nachdem Entwickler Zeit damit verbracht haben, Code für ihre neue Funktion zu schreiben, übergeben sie diesen Code normalerweise an einen neuen Git-Zweig und senden eine Pull-Anfrage oder Merge -Anfrage zurück an den Hauptzweig des Repositorys. Entwickler tun dies jeden Tag. Die Aufforderung verlangt von technischen Managern, Codeänderungen zu überprüfen und deren Einbindung in den Hauptanwendungscode zu genehmigen. Dies ist eine großartige Gelegenheit für DevOps, zusätzliche Aufgaben hinzuzufügen. Durch die Verbindung mit den von diesem Pull-Request-Prozess generierten Öffnungs-/Schließereignissen mithilfe eines Continuous-Integration-Tools (CI) können DevOps-Teams die Ausführung von Komponententests, die Erstellung von Vorschauumgebungen und die Ausführung von Integrationstests für diese Umgebungen auslösen. Mit diesem Tool können Ingenieure schnell Vertrauen in Codeänderungen aufbauen und Produktmanager können Codeänderungen in einer Pre-Merge-Vorschauumgebung sehen. Größeres Vertrauen bedeutet schnellere Fusion. Je seltener und häufiger die Daten eingegeben werden, desto weniger komplexe und unübersichtliche Rollbacks. Diese GitOps-Technik ist der Schlüssel zu schnelleren und gesünderen Entwicklungs- und Produktionsteams.

2. Mit dem Master zusammenführen und im Staging bereitstellen

Sobald alle Parteien die Änderungen überprüft haben, kann der Code zusammen mit den vom Rest des Entwicklungsteams vorgenommenen Änderungen in den Master-Zweig des Repositorys eingefügt werden. Dieser Hauptzweig wird oft als Staging-Bereich für Code verwendet, der fast produktionsreif ist. Es bleibt noch Zeit, einige operative Aufgaben wie Tests und Bereitstellung abzuschließen. Während wir normalerweise den Code für jede Pull-Anfrage testen, bevor wir sie zusammenführen, ist es eine gute Idee, die Tests erneut auszuführen, um sicherzustellen, dass der Code mit anderen vom Rest des Teams vorgenommenen Änderungen funktioniert. Es lohnt sich auch, alle diese Änderungen in einer gemeinsamen Umgebung bereitzustellen (Staging genannt), in der das gesamte Team die neuesten Änderungen überprüfen und testen kann, bevor sie für Kunden freigegeben werden.

3. Reduzieren Sie Releases und stellen Sie sie in der Produktion bereit

Nachdem Manager und Ingenieure schließlich Zeit hatten, die neuesten Änderungen am Upstream-Zweig zu überprüfen und zu testen, sind die Teams bereit, die Version freizugeben und in der Produktion bereitzustellen! Diese Aufgabe wird häufig von einem Release-Manager ausgeführt, einem dedizierten (oder rotierenden) Teammitglied, das mit der Ausführung von Bereitstellungsskripten und der Überwachung des Releases beauftragt ist. Ohne GitOps muss dieses Teammitglied überprüfen, wo sich die richtigen Skripte befinden, in welcher Reihenfolge sie ausgeführt werden sollen und ob alle richtigen Bibliotheken und Pakete, die zum Ausführen der Skripte erforderlich sind, auf ihrem Computer installiert sind. Mit GitOps können wir diese Bereitstellung mit einem anderen Git-basierten Ereignis verknüpfen – der Erstellung eines Releases oder Tags. Ein Release-Manager muss lediglich ein neues „Release“ erstellen, wobei er häufig „semver“ als Namen verwendet. Aufgaben zum Erstellen und Bereitstellen von Codeänderungen werden automatisch ausgeführt. Wie die meisten von einem CI-Tool ausgeführten Aufgaben werden sie mit dem Speicherort der Skripte und der Reihenfolge der zu ihrer Ausführung erforderlichen Bibliotheken und Pakete konfiguriert.

GitOps-Tools

Um GitOps-Prozesse wie die in diesem Artikel beschriebenen zu instrumentieren, ist nicht nur ein robustes und intuitives Tool für die kontinuierliche Integration erforderlich. Ein CI-System kann Skripte basierend auf Git-Ereignissen auslösen, aber Sie benötigen dennoch leistungsstarke Tools, um diese Skripte auszuführen und sie einfach und sicher auszuführen und zu warten. Die Bereitstellung von Codeänderungen (auch bekannt als Continuous Delivery, CD) ist einer der am schwierigsten zu automatisierenden Schritte. Aus diesem Grund haben wir mehrere Kategorien von Tools ausgewählt, die Sie auf Ihrer GitOps-Reise unterstützen können:

Containerisierung mit Docker

Docker brachte die Cloud-Entwicklung in eine völlig neue verteilte Umgebung und half Entwicklern dabei, Microservice-Architekturen realistischerweise als praktikable Option zu betrachten. Eines der Dinge, die Docker so leistungsstark machen, ist seine Bequemlichkeit für Entwickler im Vergleich zu Virtualisierungslösungen der vorherigen Generation. Wie bei den deklarativen CI-Konfigurationen in unseren Repositorys müssen Entwickler lediglich eine Docker-Datei in ihrem Repository schreiben und verwalten, um automatisierte Builds bereitgestellter virtueller Maschinen in Containern zu ermöglichen. Containerisierung ist eine äußerst wirkungsvolle Taktik für Cloud-Teams und sollte ein zentrales Werkzeug in Ihrem Repertoire sein.

Infrastruktur als Code (IaC)

Es wird viel in die Vorbereitung der Infrastruktur und die Bereitstellung von Anwendungen investiert, die nicht in einer Docker-Datei gespeichert sind. Für alles andere gibt es Infrastructure-as-Code (IaC)-Lösungen wie Terraform , Cloudformation und andere. Mit diesen Lösungen können Entwickler andere Teile der Anwendung, wie Kubernetes-Ressourcen, Load Balancer, Netzwerk, Sicherheit und mehr, deklarativ beschreiben. Genau wie die zuvor beschriebenen CI-Konfigurationen und Dockerfiles können IaC-Vorlagen einer Versionskontrolle unterliegen und von allen Entwicklern in Ihrem Team gemeinsam genutzt werden.