Verteilte Anwendungen bei Azure mit Docker und Kubernetes

Verteilte Anwendungen bei Azure
Mit Docker und Kubernetes
Gregor Biswanger | Freier Dozent, Berater, Trainer und Autor
about.me/gregor.biswanger

Über mich
▪ Freier Berater, Trainer und Autor
▪ Schwerpunkte: Softwarearchitektur, Web und
Cross-Plattform Entwicklung mit JavaScript
▪ Technologieberater für die Intel Developer Zone
▪ Internationaler Sprecher auf Konferenzen und
User Groups
▪ Freier Autor für heise.de, dotnetpro,
WindowsDeveloper und viele weitere
Fachmagazine
▪ Video-Trainer bei video2brain und Microsoft
Gregor Biswanger
Microsoft MVP, Intel Black Belt &
Intel Software Innovator
cross-platform-blog.de
about.me/gregor.biswanger

Unser Reiseplan
▪ Allgemeine Einführung
▪ Überblick von Docker
▪ Einführung in Kubernetes
▪ Nodes
▪ Master
▪ Nodes im Detail
▪ Pods im Detail
▪ Deployment
▪ Labels und Annotations
▪ Services
▪ Kubernetes Installation
▪ Die Azure Kubernetes Service (AKS)
▪ Beispielprojekt anlegen
▪ Lokales Deployment
▪ AKS Deployment
▪ AKS und VS 2017/2019
▪ Monitoring

Jetzzzt für all eure
Software!

Woher kennen wir diese Versprechen?

Wie andere Cloudplattformen auch,
basiert Azure auf einer Technologie, die
als Virtualisierung bezeichnet wird.

Der Fabric Controller ist eine verteilte
Anwendung mit vielen Aufgaben.

Er dient der Zuordnung von Diensten,
der Überwachung der Integrität des Servers und der
darauf ausgeführten Dienste, sowie
dem Wiederherstellen der Serverintegrität nach einem
Ausfall.

Nativ läuft also der Azure Service Fabric Controller

Kubernetes ist eine alternative Open-Source
Lösung zur Orchestrierung.

Vergleichbar mit der Azure Service Fabric.

Azure unterstützt beide Welten.

Beide Welten im Vergleich
Azure Service Fabric (ASF)
▪ Native API für Azure-Lösungen
▪ Integrierte Plattform mit
Unterstützung von Microsoft
einschließlich on-premises
▪ Hauptsächlich für Windows-
Lösungen
▪ Positioniert als Microservice-
Plattform zum Ausführen von
Dateien und Containern
Azure Kubernetes Service (AKS)
▪ Gehostete API on Top bei Azure
▪ Als Container Orchestrator positioniert
▪ Hauptsächlich für Linux-Lösungen
▪ Große Community-Unterstützung
▪ Von allen gängigen Cloud-Anbietern
unterstützt

Docker ist Open-Source
auf der Apache 2.0 Lizenz

Läuft Cross-Plattform auf
* *
* Benötigt eine Virtuelle Maschine

Linux Container sind seit über
10 Jahren Teil des Kernels.

Erste Umsetzung gab es beim
Free BSD Jail.
Aus Gründen der Sicherheit,
wollte man einzelne Prozesse
in andere Root-Ordner
verschieben.

Wenn beispielsweise Apache gehackt wird, hat man
nicht automatisch Berechtigung/Zugriff auf das
Gesamtsystem.

Die erste richtige Implementierung
gab es mit Solaris Zonen von Sun.

Sun wollte nicht auf eine richtige Hardware-
Virtualisierung setzen.

Linux Container (LXC) sind zu
Komplex zu administrieren.

Es fehlt an einfacher Reproduzierbarkeit und
teilweise auch um richtige Schnittstellen.

Docker ist eine
Abstraktionsschicht
der Linux Container
und Löst die
Komplexität.

Docker baute nur bis Version 0.9 auf
die nativen Linux Container auf.

Docker verwendet heute eine eigene
Implementierung und heißt Libcontainer.

Docker Architektur
Docker Daemon
Libcontainer
REST-Schnittstelle
Docker CLI (Client)
cgroups
Namespaces
MAC
Dateisysteme
Capabilities chroot

Images und Container
Docker Image
Beispiel: Ubuntu mit Node.js
und Anwendungscode
Docker Container
Erzeugt von einem Image.
Laufende Anwendung in einem
geschlossenen System.

Virtuelle Maschinen vs. Docker Container
Betriebssystem
Hypervisor
Virtuelle Maschine
Betriebssystem Betriebssystem
Bins/Libs Bins/Libs
App 1 App 2
Betriebssystem
Docker Engine (Daemon)
Docker Container
Bins/Libs Bins/Libs
App 1 App 2

Lokale Images
Docker Hub
Registry
pull
push
Run
Dockerfile
Build
Docker Container
Gestoppter Container
start stop
Commit
restart
Run-Befehl
shell
attach
stdout
history
logs

Welche Vorteile für Entwickler?

Schnelles Bereitstellen
der Entwicklungsumgebung

Vermeiden von Softwarekonflikten.
Unterschiedliche Runtime Versionen,
fehlende Dienste etc.

Schnelle Auslieferung der Software

Kubernetes („K8s“) ist ein Open-Source-System zur
Automatisierung der Bereitstellung, Skalierung
und Verwaltung von Container-Anwendungen.

Kubernetes ist altgriechisch und bedeutet
„Steuermann“.

K8s wurde ursprünglich von Google entworfen
und an die Cloud Native Computing
Foundation gespendet.

Es unterstützt eine Reihe von Container-Tools,
einschließlich Docker.

Die Orchestrierung mittels Kubernetes wird von führenden
Cloud-Plattformen wie Microsofts Azure, IBMs Bluemix,
Red Hats OpenShift, Amazons AWS und Oracles OCI
unterstützt.

K8s Cluster
Node Node
Node Node
Master
Master
Master
Pod Pod
Pod Pod
Node Node
Node Node
Pod Pod
Pod Pod

Der Kubernetes Node ist auch
bekannt als Minion.

Ein Node ist ein einzelner Server,
auf dem die Container gestartet werden.

Somit ist auf jedem Node eine
Container-Laufzeitumgebung installiert
(z. B. Docker oder rkt (Rocket))

Der Kubernetes Master ist die Steuereinheit
des Clusters, welcher die Container auf den
Nodes verteilt und verwaltet.

Es existieren mehrere Prozesse um diese
Aufgaben zu verwalten.

Diese können auf einem einzelnen Master
oder – zwecks Hochverfügbarkeit – auf
mehreren verteilt sein.

K8s Cluster
Node Node
Node Node
Pod Pod
Pod Pod
Node Node
Node Node
Pod Pod
Pod Pod
Master

Master
API-Server
Controller
Cluster Store (etcd)
kubectl
Commands
Node
Pod
Node
Pod
Scheduler

Der API Server ist eine der wichtigsten
Komponenten.

Er ist die zentrale Anlaufstelle und bedient alle
anderen Komponenten mit Informationen mittels
JSON über eine REST-Schnittstelle.

Diese Schnittstelle bietet allen internen sowie
externen Diensten die Möglichkeit, mit dem
Kubernetes Cluster zu kommunizieren.

Die Autorisierung kann über verschiedene
Mechanismen erfolgen.

Der API Server persistiert alle Informationen
(Gesamtstatus und Konfiguration) im Cluster Store (etcd).

Der etcd ist eine von CoreOS entwickelte persistente,
leichtgewichtige, verteilte Key-Value-Datenbank.

Der Scheduler entscheidet als eigenständige
Komponente, die Lastverteilung auf einzelne Nodes.

Dies ist abhängig von den zur Verfügung
stehenden Ressourcen.

Berücksichtigt werden dabei Richtlinien wie QoS,
Node-Zugehörigkeiten und z. B. Orte der Nodes
im Cluster (Rechenzentren).

Der Controller Manager ist jener Prozess, welcher
alle Kontrollmechanismen enthält, in dem z. B. ein
DaemonSet oder ein Replication Controller laufen.

Er verarbeitet die in den jeweiligen Replikationsaufgaben
definierten Replikationsprozesse.

Die dazu benötigten Informationen
werden in der etcd festgehalten.

Der Controller Manager überwacht
diese auf Änderungen.

Bei einer Änderung führt er die nötigen Schritte
aus, um den gewünschten Zustand zu erreichen.

Zum Beispiel das Skalieren eines ReplicaSet
oder das Löschen eines Pods.

Auch der Controller Manager bedient
sich hierbei beim API-Service.

Master
API-Server
Controller
Node
Pod
Scheduler

Master
API-Server
Controller
Node
Container Manager
Pod
Scheduler
Pod …
Kube-ProxycAdvisorKubelet
Benutzer

Das Kubelet ist für den Status jedes
Nodes verantwortlich.

Er wird vom Controller Manager
gesteuert und übernimmt das Starten
und Stoppen von Containern.

Wenn ein Container nicht mehr läuft,
sorgt das Kubelet auch für den Neustart
auf dem gleichen Node.

Alle paar Sekunden rapportiert er an den
Kubernetes Master über seinen Status.

Bei einem Fehler oder der Nichterreichbarkeit des
Nodes erkennt der Master dies aufgrund des
nicht gemeldeten Status.

Der Controller Manager startet dann die
Pods auf anderen "gesunden" Nodes erneut.

Der cAdvisor ist im Kubelet integriert und
zeichnet die Ressourcen (CPU, Memory)
eines Containers auf.

Andere Monitoring-Lösungen können diesen Dienst
konsultieren, um Langzeitaufzeichnungen anzubieten.

Der Kube-Proxy ist ein Proxy mit
Integriertem Load Balancer.

Er öffnet die Ports zu den Container-
Services und verwaltet die Verbindungen.

Der Container Manager hat eine
Container-Laufzeitumgebung installiert
und kann einen oder mehrere Pods
verwalten.

Pod
Docker Container
Transport
Network
Link
IPC
Mount
…

Ein Pod ist ein Wrapper für einen oder
mehrere Container.

Dieser stellt den einzelnen Containern die
zugeteilten Ressourcen zur Verfügung.

Alle Container in einem Pod, teilen sich
somit die Pod Ressourcen.

Dies ermöglicht, mehrere voneinander
abhängige Container gemeinsam lauffähig
zu halten.

Mehrere Container in einem Pod, sollten
nur untergebracht werden, wenn diese auch
voneinander abhängig sind.

Pod
Pod Lifecycle
Pod Pod
Pending Running Succeeded / Failed

Mit Deployments werden gewünschte Zustände
eines oder mehrerer Objekte definiert, die durch
den Controller sichergestellt werden.

K8s Cluster
Master
Master
Master
apiVersion: v1
kind: Pod
etadata:
YAML-Datei Replication Controller
Node
PodDeployment

Ein ReplicaSet ist eine Gruppierung, die
dafür sorgt, dass eine gewisse Anzahl
von Pods im Cluster läuft.

Deployments wiederum, bauen auf Replica Sets
auf und lassen sich darüber managen.

Ein Deployment kümmert sich dabei darum,
Replica Sets zu starten, zu aktualisieren und zu
löschen.

Deployments erzeugen bei einem
Update ein neues ReplicaSet und
skalieren die Pods nach oben.

Laufen die neuen Pods, wird das alte ReplicaSet
herunterskaliert und am Ende gelöscht.

Ein Deployment lässt sich auch
pausieren oder zurückrollen.

Alternativ können auch Pods als
DaemonSet, StatefullSet oder als
CronJobs ausgeführt werden.

Bei einem DaemonSet werden Pods auf
jeder Node im Cluster ausgeführt.

Dies ist für Infrastrukturaufgaben
geeignet. Zum Beispiel für Log-
Collectoren, Zustandsüberwachung etc.

Ein CronJob wird nach einem bestimmten
Zeitplan ausgeführt.

Labels sind Schlüssel-Wert-Paare, die an
einzelne Objekte, wie zum Beispiel Services oder
Pods gebunden werden.

Labels werden für die Organisation und
Gruppierung von einzelnen Kubernetes-
Objekten verwendet.

Sie können zu jedem Zeitpunkt hinzugefügt,
verändert oder ganz gelöscht werden.

Ein Objekt muss kein Label erhalten, der
Schlüssel hingegen muss pro Objekt gleich sein.

In einem Namespace kann es zum Beispiel
app:backend und app:frontend geben.

Die Schlüssel der Label dürfen nicht größer als
63 Zeichen lang sein.

Annotationen sind ebenfalls Schlüssel-Werte-
Paare.

Die Schlüssel der Annotationen können
beliebig lang sein.

Annotationen können nicht zur
Filterung/Selektion verwendet werden.

Labels Annotationen
"metadata": {
"labels": {
"key1": "value",
"key2": "value"
}
}
"metadata": {
"annotations": {
"key1": "value",
"key2": "value"
}
}

Bei Labels kann auf die Existenz oder Werte
selektiert werden.

apiVersion: v1
kind: Pod
metadata:
name: ...
spec:
[...]
nodeSelector:
backend: foo-bar
Wertbasierende
Selektoren

apiVersion: v1
kind: Pod
metadata:
name: ...
spec:
[...]
selector:
matchLabels:
component: nginx
matchExpressions:
- { key: foo, operator: In, values: [cache] }
- { key: environment, operator: NotIn, values: [dev] }
Set-Selektoren

Ein Service verbindet die Pods mit
der Außenwelt.

Ein Service hat immer eine feste IP-Adresse
und wird konstant bereitgestellt.

Ein Pod kann zu jedem Zeitpunkt beendet werden,
dieser wird dann durch das ReplicaSet neu erstellt
und erhält eine neue IP-Adresse.

Node
Pod Pod
Service
10.0.0.10 10.0.0.30
IP: 10.0.0.90
DNS: app.myservice

Er holt die Pods auf dem targetPort des über
den Selector gelabelten Nodes ab und erzeugt
einen zufälligen Port auf dem Node.

Dieser dient als Endpunkt für
den LoadBalancer.

In einer typischen Cloud-Umgebung sorgt der
Cloud-Provider dafür, dass diese Information bei
Kubernetes abgeholt und der richtige Endpunkt
eingetragen wird.

apiVersion: v1
kind: Service
metadata:
name: nginx-service
spec:
type: NodePort
ports:
- port: 8000 # the port that this service should serve on
targetPort: 80
protocol: TCP
selector:
app: nginx
type: LoadBalancer
Service-Definition

PaaS
▪ Konfiguration wird
übernommen
▪ Betrieb wird bis Oberkante
Cluster übernommen
▪ Schnelle Bereitstellung
▪ Keine Installations- /
Konfigurationsaufwand
▪ Höhere laufende Kosten
On-Premises
▪ Eigene Verantwortung für die
Installation
▪ Eigene Verantwortung für die
Administration
▪ Bereitstellung auf eigener
Infrastruktur
▪ Eigener Installations- /
Konfigurationsaufwand
▪ Niedrigere laufende Kosten

Play with Kubernetes
▪ Kubernetes ohne Installation
▪ Ohne Kosten
▪ Nur ein Testsetup
▪ Läuft für vier Stunden
https://labs.play-with-k8s.com

Kubernetes für die lokale Entwicklung mit Minikube

kubectl
▪ Management-Tool für Kubernetes
▪ Deployment und Upgrade von Workloads
▪ Anlegen von Kubernetes-Objekten
▪ Zugriff auf Informationen und Status
▪ Konfiguration und Installation von Komponenten
▪ Löschen von Komponenten
▪ Skalierung
▪ Wrapper um die REST-API
▪ Erlaubt Scripting und Versionierung

Azure Kubernetes Service (AKS)

Azure Kubernetes Service (AKS) verwaltet Ihre
gehostete Kubernetes-Umgebung.

AKS ermöglicht eine schnelle und einfache
Bereitstellung und Verwaltung von
Containeranwendungen.

K8s Cluster
Node Node
Node Node
Master
Master
Master
Pod Pod
Pod Pod
Node Node
Node Node
Pod Pod
Pod Pod
AKS bietet eine kostenlose
Clusterverwaltung

K8s Cluster
Node Node
Node Node
Master
Master
Master
Pod Pod
Pod Pod
Node Node
Node Node
Pod Pod
Pod Pod
Zahlen Sie nur für
Rechenressourcen

Die Azure CLI wird benötigt:
http://bit.ly/AzureCLI

Es wird ebenfalls eine Azure Subscription benötigt,
die mit der Azure CLI verknüpft ist.

C:UsersGregor>
Welcome to Azure CLI!
---------------------
Use `az -h` to see available commands or go to https://aka.ms/cli.
/
/ _____ _ _ ___ _
/ / |_ / | | | '__/ _
/ ____ / /| |_| | | | __/
/_/ _/___|__,_|_| ___|
Welcome to the cool new Azure CLI!
Use `az --version` to display the current version.
Here are the base commands:
...
C:UsersGregor>
az
Die Azure CLI mit dem AZ
Kommando

C:UsersGregor>
Note, we have launched a browser for you to login.
az login
Mit dem Azure-Account
einloggen

C:UsersGregor>
C:UsersGregor>
az account set --subscription "Azure Training Subscription"
Die gewünschte Subscription
festlegen

C:UsersGregor>
C:UsersGregor>
az aks create –g K8s-training –n my-aks --node-vm-size Standard_DS2
Alternativ kann ein neuer AKS auch
über die Azure CLI angelegt werden

C:UsersGregor>
Name Location ResourceGroup KubernetesVersion ProvisioningState
------ ---------- ------------------ ------------------- -------------------
my-aks westeurope KubernetesTraining 1.12.7 Succeeded
az aks list --output table
Alle AKS Instanzen auflisten
Fqdn
--------------------------------------------
my-aks-dns-932203eb.hcp.westeurope.azmk8s.io
C:UsersGregor>

C:UsersGregor>
------ ---------- ------------------ ------------------- -------------------
Lokalen Kontext wechseln für
die kubectl
C:UsersGregor> az aks get-credentials --name my-aks -g KubernetesTraining
Merged "my-aks" as current context in C:UsersGregor.kubeconfig
C:UsersGregor>

C:UsersGregor>
NAME STATUS ROLES AGE VERSION
aks-agentpool-12791275-0 Ready agent 40m v1.12.7
kubectl get nodes
Alle Nodes auflisten
C:UsersGregor>

C:UsersGregor>
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kubernetes ClusterIP 10.0.0.1 <none> 443/TCP 1h
kubectl get service
Alle Services auflisten
C:UsersGregor>

C:UsersGregor>
No resources found.
kubectl get pods
Alle Pods auflisten
C:UsersGregor>

Ein neues ASP.NET Core
Projekt anlegen

Die .NET Core-CLI ist ein neues plattformübergreifendes Tool
zur Entwicklung von .NET-Anwendungen mit der
Eingabeaufforderung.

C:dev>
Die Vorlage "ASP.NET Core Web App" wurde erfolgreich installiert.
Diese Vorlage enthält Technologien, die nicht von Microsoft stammen.
Weitere Informationen finden Sie unter https://aka.ms/template-3pn.
Aktionen nach der Erstellung werden verarbeitet...
Ausführen von 'dotnet restore' für HelloK8sHelloK8s.csproj...
Pakete für "C:devHelloK8sHelloK8s.csproj" werden wiederhergestellt...
Die MSBuild-Datei "C:devHelloK8sobjHelloK8s.csproj.nuget.g.props" wird generiert
Die MSBuild-Datei "C:devHelloK8sobjHelloK8s.csproj.nuget.g.targets" wird generie
Wiederherstellung in "2,04 sec" für "C:devHelloK8sHelloK8s.csproj" abgeschlossen.
Wiederherstellung erfolgreich.
C:dev>
dotnet new webapp --name HelloK8s
Der Kommando new erzeugt
ein neues Projekt

Anwendungseinstellungen
erweitern

Das Bereitstellen der eigenen Anwendung auf
Kubernetes, erfolgt durch Docker Images.

Dockerfile
Dockerfile und Images
Docker Image
docker build

Um Docker Images nicht jedes mal mühsam in der
Konsole zu erstellen, gibt es das sogenannte Dockerfile.

Ein Dockerfile ist eine simpel
aufgebaute Textdatei.

Darin wird der Aufbau eines Docker
Images beschrieben.

Dockerfile Beispiel
1. Starte Container vom Typ ubuntu
2. Führe Befehl apt-get install node aus
3. Speichere neue Version des Images ab
4. Führe Befehl apt-get install mongodb aus
5. Speichere neue Version des Images ab

Dockerfiles werden in der Regel in einer
Versionsverwaltung wie GIT hinzugefügt.

Docker hat ein Caching-Mechanismus.
Wurde ein Befehl bereits ausgeführt, wird
dieser aus dem Cache schneller verarbeitet.

Der Vorteil von Dockerfiles ist die
Reproduzierbarkeit. Ein Zustand kann
jederzeit wiederhergestellt werden.

Eine Dockerfile dient ebenfalls als saubere
Systemaufbaudokumentation.

Das Management von Lizenzierungen wird
vereinfacht. Es wird eine Art „Archivierung“
von Lizenzen vermieden.

Mit der .dockerignore-Datei können auch
Verzeichnisse/Dateien beim Verarbeiten
ignoriert werden.

VS Code Extension hilft beim
Erzeugen von Docker-Dateien

Mit der F1-Taste die
Command-Line öffnen

Fertige Docker-File
für ASP.NET Core

C:devHelloK8s>
Sending build context to Docker daemon 5.521MB
Step 1/13 : FROM microsoft/aspnetcore-build AS publish
---> 06a6525397c2
Step 2/13 : WORKDIR /publish
---> Using cache
---> 35f41382bb00
...
...
...
...
...
...
Successfully built 0fa76744a1fb
Successfully tagged hellok8s:local
C:devHelloK8s>
docker build -t hellok8s:local .
Tag für
Imagename
Von welchen
Pfad
Docker Build erzeugt
ein Docker Image

C:devHelloK8s>
REPOSITORY TAG IMAGE ID CREATED SIZE
hellok8s local 0fa76744a1fb About a minute ago 264MB
C:devHelloK8s>
docker images
Image wurde erzeugt

C:devHelloK8s>
274fec1e33e4b02bd88b7d291819554027172d08338f7acb5af058ef8c44d38a
C:devHelloK8s>
docker run -d --rm -p 80:80 hellok8s:local
Eigenes Image als
Container starten
Port Mapping
Host-Port:Container-Port
Container Remove
Entfernt Container wenn dieser gestoppt
wurde
Daemon
„Im Hintergrund Ausführen“

Webseite vom
Container öffnen

C:devHelloK8s>
274
C:devHelloK8s>
docker stop 274
Container beenden

Unterschiedliche Methoden zum Deployen
▪ Interaktiv über Kubectl
▪ Interaktiv über das Kubernetes Dashboard
▪ Über eine YAML/JSON-Datei
▪ Helper für das Erzeugen der YAML-Datei:
https://static.brandonpotter.com/kubernetes/DeploymentBuilder.html
▪ Vorhandene docker-compose-Datei zu YAML-Datei mit Kompose:
http://kompose.io
▪ Visual Studio 2019 hat ein integriertes Tooling via Helm (Package
Manager für Kubernetes)

Anwendung auf Kubernetes ausführen
Schritt 1
Anwendung in
Docker Images
verpacken
Schritt 2
Docker Images
auf einem
Image Registry
veröffentlichen
Schritt 3
K8s
Konfigurations-
Datei
ausführen
Schritt 4
K8s zieht sich
die Docker
Images
Schritt 5
K8s Scheduler
erzeugen
Container auf
verfügbaren
Nodes

C:dev>
deployment.apps "hellok8s-deployment" created
kubectl run hellok8s-deployment --image=hellok8s:local --port=80 --replicas=3
Lokal starten über Kubectl
C:dev> kubectl get deployments
C:dev>
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
hellok8s-deployment 3 3 3 3 4s
C:dev> kubectl get pods
NAME READY STATUS RESTARTS AGE
hellok8s-deployment-86dfccfb99-d6vd9 1/1 Running 0 8s
hellok8s-deployment-86dfccfb99-lzqrj 1/1 Running 0 8s
hellok8s-deployment-86dfccfb99-vckch 1/1 Running 0 8s

C:dev>
service "hellok8s-deployment" exposed
kubectl expose deployment hellok8s-deployment --type=NodePort
Service für den öffentlichen
Zugriff anlegen
C:dev> kubectl get services
hellok8s-deployment NodePort 10.105.178.103 <none> 80:30514/TCP 7s
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 1d
C:dev>

Webseite wird automatisch von
unterschiedlichen Pods ausgeführt.

C:dev>
deployment.extensions "hellok8s-deployment" deleted
kubectl delete deployment hellok8s-deployment
Lokales deployment und
Service löschen
C:dev> kubectl delete service hellok8s-deployment
service "hellok8s-deployment" deleted
C:dev>

C:devHelloK8s>
deployment.apps "hellok8s-deployment" created
service "hellok8s-deployment-service" created
kubectl create -f .hellok8s-deploy.yml
Lokal starten über
Konfigurations-Datei
C:devHelloK8s> kubectl get services
hellok8s-deployment-service NodePort 10.100.80.72 <none> 80:31872/TCP 40s
C:devHelloK8s>

C:devHelloK8s>
deployment.apps "hellok8s-deployment" deleted
service "hellok8s-deployment-service" deleted
kubectl delete -f .hellok8s-deploy.yml
Lokales deployment und
Service löschen
C:devHelloK8s>

Mein Source-Code Browser
Mein Deployment Ziel

Mein Source-Code Browser
Mein Deployment Ziel
1. Erzeugt Docker Images
2. Veröffentlicht Docker Images
3. Startet Kubectl mit Konfig-Datei

Die Azure Container Registry bietet das
Hosting in der Cloud für Docker Repositories.

AKS die Lese-Rolle zur
Berechtigung zuweisen

GitHub Projekt anlegen und
Source-Code veröffentlichen

Azure DevOps Projekt anlegen
und Build-Pipeline erzeugen

Mit GitHub Projekt
verknüpfen

Kubectl mit Konfig-
Datei ausführen

Code einchecken und auf
GitHub pushen.

C:devHelloK8s>
hellok8s-deployment-service LoadBalancer 10.0.169.218 13.80.2.197 80:31211/TCP 17h
kubectl get services --watch
IP-Adresse vom
Service ermitteln

Visual Studio 2019 + AKS
▪ VS 2019 unterstützt AKS
▪ Projekt-Template
▪ Team-Support mit „Azure Dev Spaces“
▪ Debug direkt von Kubernetes aus der Cloud
▪ Deployment
▪ Docker Support
▪ Helm Support
▪ „Draft Support“
▪ Für VS 2017 gibt es die Erweiterung:
„Visual Studio Tools for Kubernetes”
▪ https://marketplace.visualstudio.com/items?itemName=ms-
azuretools.vs-tools-for-kubernetes

C:UsersGregor>
------ ---------- ------------------ ------------------- -------------------
C:UsersGregor> kubectl create clusterrolebinding kubernetes-dashboard
clusterrolebinding.rbac.authorization.k8s.io "kubernetes-dashboard" created
C:UsersGregor>
--clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard
az aks browse --name my-aks --resource-group KubernetesTraining
Merged "my-aks" as current context in C:UsersGregorAppDataLocalTemptmpugirr5az
Proxy running on http://127.0.0.1:8001/
Press CTRL+C to close the tunnel...
Forwarding from 127.0.0.1:8001 -> 9090
Forwarding from [::1]:8001 -> 9090
Handling connection for 8001
Zugreifen auf das Kubernetes-
Webdashboard in AKS

Beispielcode:
https://github.com/GregorBiswanger/HelloKubernetes

http://about.me/Gregor.Biswanger
Ich freue mich auf Feedback!
Vielen Dank!

Verteilte Anwendungen bei Azure mit Docker und Kubernetes

Weitere ähnliche Inhalte

Was ist angesagt?

Ähnlich wie Verteilte Anwendungen bei Azure mit Docker und Kubernetes

Mehr von Gregor Biswanger

Verteilte Anwendungen bei Azure mit Docker und Kubernetes