Oefening: infrastructuurtolerantie implementeren met Kubernetes

11 minuten

In de vorige les hebt u tolerantie geïmplementeerd door code voor foutafhandeling toe te voegen met behulp van de extensie voor systeemeigen tolerantie van .NET. Deze wijziging is echter alleen van toepassing op de service die u hebt gewijzigd. Het bijwerken van een grote app met veel services zou niettrivieel zijn.

In plaats van op code gebaseerde tolerantie te gebruiken, gebruikt deze eenheid een benadering met de naam infrastructuurgebaseerde tolerantie die de hele app omvat. U doet het volgende:

Implementeer de app opnieuw zonder enige tolerantie in Kubernetes.
Linkerd implementeren in uw Kubernetes-cluster.
Configureer de app om Linkerd te gebruiken voor veerkracht.
Verken het app-gedrag met Linkerd.

De app opnieuw implementeren

Voordat u Linkerd toepast, moet u de app terugzetten naar een status voordat tolerantie op basis van code is toegevoegd. Voer de volgende stappen uit om terug te keren:

Selecteer in het onderste deelvenster het tabblad TERMINAL en voer de volgende Git-opdrachten uit om de wijzigingen ongedaan te maken:
```
cd Store
git checkout Program.cs
git checkout Store.csproj
cd ..
dotnet publish /p:PublishProfile=DefaultContainer
```

Kubernetes installeren

Installeer Kubernetes en k3d in uw codespace. k3d is een hulpprogramma dat een Kubernetes-cluster met één knooppunt uitvoert binnen een virtuele machine (VM) op uw lokale computer. Het is handig voor het lokaal testen van Kubernetes-implementaties en wordt goed uitgevoerd in een coderuimte.

Voer deze opdrachten uit om Kubernetes en MiniKube te installeren:

curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/kubernetes-apt-keyring.gpg

echo 'deb [signed-by=/etc/apt/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt-get update
sudo apt-get install -y kubectl

curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

De eShop-services implementeren in Docker Hub

De lokale installatiekopieën van uw services die u bouwt, moeten worden gehost in een containerregister om te kunnen worden geïmplementeerd in Kubernetes. In deze eenheid gebruikt u Docker Hub als uw containerregister.

Voer deze commando's uit om je afbeeldingen naar Docker Hub te pushen.

sudo docker login

sudo docker tag products [your username]/productservice
sudo docker tag store [your username]/storeimage

sudo docker push [your username]/productservice
sudo docker push [your username]/storeimage

Uw docker-compose-bestand converteren naar Kubernetes-manifesten

Op dit moment definieert u hoe uw app wordt uitgevoerd in Docker. Kubernetes gebruikt een andere indeling om te definiëren hoe uw app wordt uitgevoerd. U kunt een hulpprogramma met de naam Kompose gebruiken om uw docker-compose-bestand te converteren naar Kubernetes-manifesten.

Je moet deze bestanden bewerken om de afbeeldingen die je naar Docker Hub hebt gepusht te gebruiken.
Open in de codespace het bestand backend-deploy.yml.
Wijzig deze regel:
```
  containers:
    - image: [YOUR DOCKER USER NAME]/productservice:latest
```
Vervang de tijdelijke aanduiding [UW DOCKER-GEBRUIKERSNAAM] door uw werkelijke Docker-gebruikersnaam.
Herhaal deze stappen voor het frontend-deploy.yml-bestand.
Wijzig deze regel:
```
  containers:
  - name: storefrontend
    image: [YOUR DOCKER USER NAME]/storeimage:latest  
```
Vervang de tijdelijke aanduiding [UW DOCKER-GEBRUIKERSNAAM] door uw werkelijke Docker-gebruikersnaam.

Implementeer de eShop-app in Kubernetes:

kubectl apply -f backend-deploy.yml,frontend-deploy.yml

U zou uitvoer moeten zien die vergelijkbaar is met de volgende berichten:

deployment.apps/productsbackend created
service/productsbackend created
deployment.apps/storefrontend created
service/storefrontend created

Controleer of alle diensten actief zijn.

kubectl get pods

U zou een uitvoer moeten zien die vergelijkbaar is met de volgende berichten:

NAME                        READY   STATUS    RESTARTS   AGE
backend-66f5657758-5gnkw    1/1     Running   0          20s
frontend-5c9d8dbf5f-tp456   1/1     Running   0          20s

Ga naar het tabblad POORTEN. Om de eShop te bekijken die op Kubernetes draait, selecteer je het wereldbolpictogram naast de Front End (32000) poort.

Linkerd installeren

Voor de dev-container moet Linkerd CLI worden geïnstalleerd. Voer de volgende opdracht uit om te controleren of aan de vereisten van Linkerd is voldaan:

curl -sL run.linkerd.io/install | sh
export PATH=$PATH:/home/vscode/.linkerd2/bin
linkerd check --pre

Er wordt een variant van de volgende uitvoer weergegeven:

kubernetes-api
--------------
√ can initialize the client
√ can query the Kubernetes API

kubernetes-version
------------------
√ is running the minimum Kubernetes API version
√ is running the minimum kubectl version

pre-kubernetes-setup
--------------------
√ control plane namespace does not already exist
√ can create non-namespaced resources
√ can create ServiceAccounts
√ can create Services
√ can create Deployments
√ can create CronJobs
√ can create ConfigMaps
√ can create Secrets
√ can read Secrets
√ can read extension-apiserver-authentication configmap
√ no clock skew detected

pre-kubernetes-capability
-------------------------
√ has NET_ADMIN capability
√ has NET_RAW capability

linkerd-version
---------------
√ can determine the latest version
√ cli is up-to-date

Status check results are √

Linkerd implementeren in Kubernetes

Voer eerst de volgende opdracht uit om de aangepaste resourcedefinities (CRD's) te installeren:

linkerd install --crds | kubectl apply -f -

Voer vervolgens de volgende opdracht uit:

linkerd install --set proxyInit.runAsRoot=true | kubectl apply -f -

In de voorgaande opdracht:

linkerd install genereert een Kubernetes-manifest met de benodigde besturingsvlakbronnen.
Het gegenereerde manifest wordt doorgesluisd naar kubectl apply, waarmee deze besturingsvlakbronnen in het Kubernetes-cluster worden geïnstalleerd.

De eerste regel van de uitvoer laat zien dat het besturingsvlak is geïnstalleerd in een eigen linkerd naamruimte. De resterende uitvoer vertegenwoordigt de objecten die worden aangemaakt.

namespace/linkerd created
clusterrole.rbac.authorization.k8s.io/linkerd-linkerd-identity created
clusterrolebinding.rbac.authorization.k8s.io/linkerd-linkerd-identity created
serviceaccount/linkerd-identity created
clusterrole.rbac.authorization.k8s.io/linkerd-linkerd-controller created

De Linkerd-implementatie valideren

Voer de volgende opdracht uit:

linkerd check

Met de voorgaande opdracht worden de configuraties van de Linkerd CLI en het besturingsvlak geanalyseerd. Als Linkerd correct is geconfigureerd, wordt de volgende uitvoer weergegeven:

kubernetes-api
--------------
√ can initialize the client
√ can query the Kubernetes API

kubernetes-version
------------------
√ is running the minimum Kubernetes API version
√ is running the minimum kubectl version

linkerd-existence
-----------------
√ 'linkerd-config' config map exists
√ heartbeat ServiceAccount exist
√ control plane replica sets are ready
√ no unschedulable pods
√ controller pod is running
√ can initialize the client
√ can query the control plane API

linkerd-config
--------------
√ control plane Namespace exists
√ control plane ClusterRoles exist
√ control plane ClusterRoleBindings exist
√ control plane ServiceAccounts exist
√ control plane CustomResourceDefinitions exist
√ control plane MutatingWebhookConfigurations exist
√ control plane ValidatingWebhookConfigurations exist
√ control plane PodSecurityPolicies exist

linkerd-identity
----------------
√ certificate config is valid
√ trust anchors are using supported crypto algorithm
√ trust anchors are within their validity period
√ trust anchors are valid for at least 60 days
√ issuer cert is using supported crypto algorithm
√ issuer cert is within its validity period
√ issuer cert is valid for at least 60 days
√ issuer cert is issued by the trust anchor

linkerd-api
-----------
√ control plane pods are ready
√ control plane self-check
√ [kubernetes] control plane can talk to Kubernetes
√ [prometheus] control plane can talk to Prometheus
√ tap api service is running

linkerd-version
---------------
√ can determine the latest version
√ CLI is up to date

control-plane-version
---------------------
√ control plane is up to date
√ control plane and CLI versions match

linkerd-addons
--------------
√ 'linkerd-config-addons' config map exists

linkerd-grafana
---------------
√ grafana add-on service account exists
√ grafana add-on config map exists
√ grafana pod is running

Status check results are √

Tip

Als u een lijst met Linkerd-onderdelen wilt zien die zijn geïnstalleerd, voert u deze opdracht uit: kubectl -n linkerd get deploy

De app configureren voor het gebruik van Linkerd

Linkerd wordt geïmplementeerd, maar is niet geconfigureerd. Het gedrag van de app is ongewijzigd.

Linkerd is niet op de hoogte van interne service en kan niet bepalen of het geschikt is om een mislukte aanvraag opnieuw uit te voeren. Het is bijvoorbeeld een slecht idee om een mislukte HTTP POST opnieuw te proberen voor een betaling. Daarom is een serviceprofiel nodig. Een serviceprofiel is een aangepaste Kubernetes-resource waarmee routes voor de service worden gedefinieerd. Het maakt ook functies per route mogelijk, zoals nieuwe pogingen en time-outs. Linkerd probeert alleen routes opnieuw uit te proberen die zijn geconfigureerd in het manifest van het serviceprofiel.

Implementeer omwille van de beknoptheid Linkerd alleen voor de aggregator- en couponservices. Als u Linkerd voor deze twee services wilt implementeren, gaat u als volgt te werk:

Wijzig de eShop-implementaties zodat Linkerd de proxycontainer in de pods maakt.
Configureer herhalingen op de route van de couponservice door een serviceprofielobject aan het cluster toe te voegen.

De eShop-implementaties wijzigen

De services moeten worden geconfigureerd voor het gebruik van Linkerd-proxycontainers.

Voeg de linkerd.io/inject: enabled aantekening toe aan het backend-deploy.yml-bestand onder sjabloonmetagegevens.
```
  template:
    metadata:
      annotations:
        linkerd.io/inject: enabled
      labels: 
```
Voeg de linkerd.io/inject: enabled aantekening toe aan het frontend-deploy.yml-bestand op dezelfde plaats.

Werk de implementaties in het Kubernetes-cluster bij:

kubectl apply -f backend-deploy.yml,frontend-deploy.yml

Het Linkerd-serviceprofiel toepassen voor de productservice

Het serviceprofielmanifest voor de productservice is:

apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: backend
  namespace: default
spec:
  routes:
  - condition:
      method: GET
      pathRegex: /api/Product
    name: GET /v1/products
    isRetryable: true
  retryBudget:
    retryRatio: 0.2
    minRetriesPerSecond: 10
    ttl: 120s

Het voorgaande manifest is zo geconfigureerd:

Elke idempotente HTTP GET-route die overeenkomt met het patroon /api/Product kan opnieuw worden geprobeerd.
Nieuwe pogingen kunnen niet meer dan 20 procent extra toevoegen aan de belasting van verzoeken, daarbovenop nog 10 'gratis' nieuwe pogingen per seconde.

Voer de volgende opdracht uit om het serviceprofiel in het Kubernetes-cluster te gebruiken:

kubectl apply -f - <<EOF
apiVersion: linkerd.io/v1alpha2
kind: ServiceProfile
metadata:
  name: backend
  namespace: default
spec:
  routes:
  - condition:
      method: GET
      pathRegex: /api/Product
    name: GET /v1/products 
    isRetryable: true
  retryBudget:
    retryRatio: 0.2
    minRetriesPerSecond: 10
    ttl: 120s  
EOF

De volgende uitvoer wordt weergegeven:

serviceprofile.linkerd.io/backend created

Bewaking installeren op de servicemesh

Linkerd heeft extensies om u extra functies te bieden. Installeer de viz-extensie en bekijk de status van de app in het dashboard van Linkerd.

Voer in de terminal deze opdracht uit om de extensie te installeren:
```
linkerd viz install | kubectl apply -f -
```
Bekijk het dashboard met deze opdracht:
```
linkerd viz dashboard
```
Ga naar het tabblad POORTEN en bekijk een nieuwe poort die is doorgestuurd terwijl het proces van linkerd viz dashboard draait. Selecteer Openen in browser om het dashboard te openen.
Selecteer in het Linkerd-dashboard Namespaces.
Onder HTTP-metrieken, selecteer standaard.

Linkerd-veerkracht testen

Nadat de opnieuw geïmplementeerde containers in orde zijn, gebruikt u de volgende stappen om het gedrag van de app met Linkerd te testen:

Controleer de status van de actieve pods met deze opdracht:
```
kubectl get pods --all-namespaces
```

Stop alle productservice-pods:

kubectl scale deployment productsbackend --replicas=0

Ga naar de eShop-web-app en probeer de producten te bekijken. Er is een vertraging totdat het foutbericht wordt weergegeven, 'Er is een probleem met het laden van onze producten. Probeer het later opnieuw.'

Start de product-service pods opnieuw op.

kubectl scale deployment productsbackend --replicas=1

De producten worden nu weergegeven in de app.

Linkerd volgt een andere benadering van tolerantie dan wat u hebt gezien met tolerantie op basis van code. Linkerd heeft de bewerking meerdere keren achter elkaar opnieuw geprobeerd. De app hoeft niet te worden gewijzigd om dit gedrag te ondersteunen.

Aanvullende informatie

Zie de volgende bronnen voor meer informatie over linkerd-configuratie: