Sollten Sie Kubernetes verwenden? Die Antwort lautet kurz gesagt: Es kommt darauf an. Aber lassen Sie mich Sie durch meine Reise zum Verständnis von Kubernetes führen, und vielleicht hilft es Ihnen, Ihre eigene Antwort zu finden.
Ich habe ein ganzes Buch geschrieben, um Sie auf Ihrem Weg zu Kubernetes zu begleiten (die Vorabversion MEAP von Manning erhalten Sie hier). Aber bevor wir über das Buch sprechen, sollten wir ein wenig über die Bereitstellung von Software und meinen Weg dorthin sprechen.
Vor fast zwei Jahrzehnten unternahm ich meinen ersten Versuch, Software im Internet einzusetzen, um meine erste Website zu veröffentlichen. Damals hatte ich keinen blassen Schimmer, wo ich überhaupt anfangen sollte. Ein paar Freunde der Familie waren so freundlich, mir einen Rat zu geben:
Der Unternehmer schlug vor:
"Wenn Sie dieses Buch über Dreamweaver und HTML in die Hand nehmen, werden Sie keinen Cent für die Entwicklung Ihrer ersten Website ausgeben müssen."
Der Systemadministrator und der Entwickler verfolgten einen anderen Ansatz:
"Lassen Sie mich einen FTP-Server für Sie einrichten, damit Sie Ihre Website hosten können; ich empfehle Ihnen nicht, sich mit der Verwaltung von Servern zu befassen.
Beide haben mir geholfen, dorthin zu kommen, wo ich heute bin, aber einer von ihnen hat mein Lernen ungewollt lange verzögert. Können Sie erraten, wer?
Wenn ich auf meine Anfänge zurückblicke, wird deutlich, wie wichtig sowohl das Grundlagenwissen als auch das Lernen durch praktische Erfahrung für meinen Weg waren. Der Rat des Unternehmers drängte mich dazu, praktisch in die Webentwicklung einzutauchen, während die Anleitung des Systemadministrators mir den Wert von Tools vermittelte, die komplexe Aufgaben vereinfachen können.
Eine wichtige Lektion, die sich im Laufe der Zeit herauskristallisierte, war jedoch, wie wichtig es ist, die grundlegenden Prinzipien zu verstehen, selbst wenn man High-Level-Tools verwendet. Diese frühe Lernerfahrung war der Ursprung meines Interesses an Kubernetes, einer Technologie, die meinen beruflichen Werdegang maßgeblich beeinflussen sollte. Um Kubernetes zu verstehen, muss man, wie bei jedem anderen Tool auch, die zugrunde liegende Technologie beherrschen.
Ist Kubernetes komplex? Ja. Ist es perfekt? Nein. Ist es für alle Situationen geeignet? Nein. Aber die Frage, ob Sie Kubernetes verwenden sollten oder nicht, hängt oft davon ab, ob Sie die zugrunde liegende Technologie verstehen, die Kubernetes so leistungsfähig macht, und wie Sie sie zur Verwaltung und zum Schutz Ihrer Software einsetzen können.
Für diejenigen unter Ihnen, die sich fragen: "Was ist Kubernetes?" oder die vielleicht noch nicht mit dem Begriff "Docker" (abgesehen von der Art der Hose) und seiner Assoziation mit Containern vertraut sind, möchte ich eine Erklärung geben.
Anwendungen werden ständig weiterentwickelt, wobei jede Komponente, von der Datenbank bis zur Programmiersprache, häufig neue Versionen herausbringt. Die Verwaltung mehrerer Versionen jeder Anwendung und zahlreicher Iterationen von Drittanbieter-Komponenten kann zu einer mühsamen Angelegenheit werden, vor allem, wenn es sich um ältere oder veraltete Versionen ohne Mainstream-Support handelt. Selbst bei unterstützten Softwareversionen gibt es viele Abhängigkeiten auf Systemebene und von Drittanbietern, die die Ausführung der Software erschweren, ganz zu schweigen von dem Versuch, sie als Komponente Ihrer Anwendung zu verwenden.
Mit der Zeit veraltet jede Software und wird durch neuere Versionen ersetzt. Die Herausforderung besteht darin, ältere Software bei Bedarf zu verwenden. Selbst scheinbar kleine Änderungen in der Software können große Auswirkungen auf moderne Anwendungen haben. Ein Beispiel: Python 2.7 (im Vergleich zur neuesten Version Python 3.11) war früher in Apples Mac OS X integriert. Python 2.7 hatte eine seltsame Syntax für die Ausgabe von Text auf der Befehlszeile: `print "this thing"` anstelle der logischeren Version von `print("this thing")`, die in neueren Versionen von Python enthalten ist. Dieser eine Teil der Syntax kann eine gesamte ältere Python Anwendung wegen fehlender Klammern zerstören.
Obwohl die Verwendung älterer Softwareversionen unpraktisch sein kann, gibt es sicherlich Situationen, in denen wir ältere Software einsetzen müssen. Aber wie?
Wir könnten die Zeit damit verbringen, ein Stück Hardware oder ein VM-Image aus einer bestimmten Zeit zu finden, das es uns ermöglicht, eine alte Software auszuführen. Oder wir können auf Container zurückgreifen, ein Konzept, das von Docker eingeführt wurde. Bei Containern handelt es sich um in sich geschlossene Anwendungen, die mit ihren Abhängigkeiten verpackt sind und die wir nach Belieben ändern können. Ihr Alleinstellungsmerkmal ist die Fähigkeit, nahtlos von einem System auf ein anderes zu wechseln.
Hier ist ein Beispiel für ein Dockerfile, das Python 2.7 als Baustein eines Containers verwendet:
```dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
``````dockerfile
FROM python:2.7.7-slim
COPY ./src /app/
WORKDIR /app
RUN python -m pip install -r requirements.txt
CMD [“python”, “manage.py”, “runserver”]
```Diese Dockerdatei teilt Docker mit, was benötigt wird, um diesen neuen Container mit Code zu erstellen, der auf unserem lokalen Rechner und in unserem lokalen Pfad unter "/src" vorhanden ist. Dockerdateien können sehr viel komplizierter werden, aber dieses Beispiel zeigt, wie einfach die Verwendung von Docker sein kann.
Um diese containerisierte Anwendung zu erstellen und auszuführen, ist es so einfach wie:
```bash
docker build -f Dockerfile -t hello-python:v1 .
docker run hello-python -p 8000:8000
```Ohne Containerisierung müssten wir Python 2.7 direkt auf einem Rechner installieren, was fast nie einfach ist. Docker und andere Container können unsere Anwendungen portabel machen, und Sie können Python 2.7 in diesem Beispiel durch fast jede Open-Source-Sprache oder jedes Tool ersetzen.
Das Problem entsteht jedoch, wenn wir eine containerisierte Anwendung aktualisieren wollen, insbesondere in der Produktion. Lokal ist das Aktualisieren eines Containers einfach. Man stoppt die Ausführung des Containers, baut ihn neu und führt ihn dann erneut aus. In der Produktion kann die Aktualisierung eines Containers auf die gleiche Weise durchgeführt werden, aber es besteht die Gefahr, dass es zu erheblichen Ausfallzeiten kommt, wenn der Build fehlschlägt.
An dieser Stelle kommt Kubernetes ins Spiel. Kubernetes hilft dabei, den Datenverkehr zu bestimmten Containern zu leiten und überwacht die Anzahl der Container, die zu einem bestimmten Zeitpunkt laufen. Wenn ein Container ausfällt, ermöglicht Kubernetes ein einfaches Rollback zu früheren Versionen mit minimaler oder gar keiner Ausfallzeit.
Die Konfiguration für die Bereitstellung eines Containers in Kubernetes wird als Manifest bezeichnet. Hier ist ein Beispiel für ein relativ einfaches Manifest:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-py-deploy
spec:
replicas: 3
selector:
matchLabels:
app: hello-py-deploy
template:
metadata:
labels:
app: hello-py-deploy
spec:
containers:
- name: hello-py-container
image: jmitchel3/hello-python:v1
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: hello-py-service
spec:
type: LoadBalancer
ports:
- name: http
port: 80
targetPort: 8080
protocol: TCP
selector:
app: hello-py-deploy
```Im obigen Beispiel stellt das yaml-formatierte Kubernetes-Manifest zwei Ressourcen bereit: einen Lastausgleichsdienst und eine Bereitstellung. Der Lastausgleichsdienst hilft dabei, den Datenverkehr zu unserer Bereitstellung zu leiten. Über `replicas: 3" unseres deklarierten Containers "hello-python:v1" läuft unser Deployment in 3 Versionen.
Wenn wir nun die bereitgestellte Version aktualisieren wollen, können wir einfach `hello-python:v1` in `hello-python:v2` ändern und Kubernetes wird unsere Anwendung ordnungsgemäß aktualisieren. Und wenn etwas schief geht, wird es zu `hello-py-deploy:v1` zurückkehren. Kubernetes macht diesen Prozess schmerzlos und einfach zu verwalten. Manifeste lassen sich mit Git leicht versionskontrollieren, sodass wir unsere Rollback-Fähigkeiten sehr granular gestalten können. Kubernetes ist ein wesentlicher Bestandteil der Bereitstellung, da es ein Framework für die Automatisierung, Skalierung und Verwaltung von containerisierten Anwendungen bereitstellt und so die Ausfallsicherheit und Effizienz des Systems in unseren zunehmend komplexen Softwarelandschaften gewährleistet.
Ich wollte nur einige der Methoden vorstellen, die mich dazu brachten, herauszufinden, wie Kubernetes meine Anwendungsbereitstellungen vereinfachen kann. Um das Beste aus Kubernetes herauszuholen, brauchte ich mehrere Schritte, aber es war eine lohnende Reise. In Road to Kubernetes (Weg zu Kubernetes) begeben wir uns auf eine Reise zur Bereitstellung von Anwendungen mit verschiedenen Technologien, die man verstehen sollte, bevor man sich auf Kubernetes und andere moderne Bereitstellungsmethoden einlässt.
In Road to Kubernetes gehen wir durch, wie man:
- Verwaltung von Git-Repositories auf selbst gehosteten oder Cloud-Plattformen
- Bereitstellung von Python und Node.js Anwendungen über Cloud-basierte VMs mit Git
- Automatisieren Sie die VM-Konfiguration und -Bereitstellung mit Ansible
- Containerisierung und Bereitstellung von Anwendungen mit Docker und Docker Compose
- Container direkt auf VMs ohne Orchestrierung ausführen
- Container mit der DockerHub-Registry pushen und hosten
- Bereitstellung von containerisierten Anwendungen auf Kubernetes
- Implementierung öffentlicher und privater Anwendungen auf Kubernetes
- Konfigurieren von Lastverteilern für HTTP- und HTTPs-Verkehr
- Nutzung von CI/CD-Techniken mit Github Actions und der Open-Source-Alternative Act von Nectos
- und mehr!
Das Deployment ist der ultimative Test für Ihre Software. Road to Kubernetes fasst fünfzehn Jahre Erfahrung mit der Bereitstellung in einem zugänglichen und praktischen Leitfaden zusammen. Es führt Sie von der Bereitstellung von Software von Grund auf bis hin zur Implementierung der Leistung von Kubernetes. Sie lernen nachhaltige Bereitstellungspraktiken, die Sie mit jeder Sprache und jeder Art von Webanwendung verwenden können, wie Sie portable Anwendungen erstellen, die über verschiedene Bereitstellungsoptionen und Cloud-Anbieter hinweg eingesetzt werden können, und sehen, wie möglich es ist, Kubernetes für Projekte jeder Größe zu nutzen.
Kommentare