Partager via

Déployer des applications avec Helm

  • Article

S’applique à : AKS sur Azure Stack HCI 22H2, AKS sur Windows Server

Helm est un outil d’empaquetage open source qui vous aide à installer et à gérer le cycle de vie d’applications Kubernetes. À l’instar des gestionnaires de package Linux, tels qu’APT et Yum, Helm sert à gérer les charts Kubernetes, qui sont des packages de ressources Kubernetes préconfigurées.

Cet article explique comment utiliser Helm pour empaqueter et déployer des applications sur AKS lorsque vous utilisez Azure Kubernetes Service activé par Azure Arc.

Avant de commencer

Vérifiez que les exigences suivantes sont remplies :

  • Un cluster Kubernetes avec au moins un nœud Worker Windows ou Linux opérationnel.
  • Vous avez configuré votre environnement local kubectl pour qu’il pointe vers votre cluster. Vous pouvez utiliser la commande PowerShell Get-AksHciCredential pour accéder à votre cluster à l’aide de kubectl.
  • La ligne de commande Helm v3 et les prérequis sont installés.
  • Vous avez un registre de conteneurs disponible, tel que DockerHub ou Azure Container Registry.

Cet article utilise une application ASP.NET Core comme exemple. Vous pouvez télécharger l’exemple d’application à partir de ce dépôt GitHub.

Étant donné que l’application est déployée sur Kubernetes, l’exemple suivant est un fichier Dockerfile simple pour le projet :

FROM mcr.microsoft.com/dotnet/aspnet:5.0-alpine AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:5.0-alpine AS build
WORKDIR /src
COPY ["MyMicroservice.csproj", "./"]
RUN dotnet restore "MyMicroservice.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "MyMicroservice.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyMicroservice.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyMicroservice.dll"]

Générer et pousser l’exemple d’application à un registre de conteneurs

Accédez au dossier de l’application et utilisez le fichier Dockerfile pour générer et envoyer une image à l’aide de la commande suivante :

docker build -f Dockerfile -t acr.azurecr.io/mymicroservice:0.1.0 .

Remarque

Le point (.) à la fin de la commande définit l’emplacement du fichier Dockerfile (en l’occurrence, le répertoire actif).

Cette commande crée l’image mymicroservice:0.1.0 sur l’ordinateur local. Pour vérifier que l’image a été correctement créée, exécutez-la docker images pour confirmer :

REPOSITORY              TAG     IMAGE ID       CREATED            SIZE  
acr.azurecr.io/mymicroservice 0.1.0   5be713db571b   About a minute ago 107MB
....

Ensuite, envoyez votre image à un registre de conteneurs, tel que DockerHub ou Azure Container Registry. Dans cet exemple, l’image conteneur est envoyée (push) à Azure Container Registry. Pour plus d’informations, consultez Extraire des images d’un ACR vers un cluster Kubernetes :

docker push acr.azurecr.io/mymicroservice:0.1.0

Créer votre chart Helm

Maintenant que l’exemple d’application est prêt, l’étape suivante consiste à générer un graphique Helm à l’aide de la helm create commande, comme suit :

helm create mymicroserviceapp

Mettez à jour mymicroserviceapp/values.yaml, comme suit :

  • Changez image.repository en acr.azurecr.io/mymicroservice.
  • Changez service.type en NodePort.

Par exemple :

# Default values for webfrontend.
# This is a YAML-formatted file.
# Declare variables to be passed into your templates.

replicaCount: 1

image:
  repository: acr.azurecr.io/mymicroservice
  pullPolicy: IfNotPresent
...
service:
  type: NodePort
  port: 80
...

Accédez au fichier mymicroserviceapp/templates/deployment.yaml pour configurer les contrôles d’intégrité. Kubernetes utilise des contrôles d’intégrité pour gérer les déploiements de vos applications. Remplacez le chemin d’accès aux deux liveness et readiness sondes path: /weatherforecastpar , comme illustré dans l’exemple suivant :

...
 livenessProbe:
    httpGet:
      path: /weatherforecast
      port: http
    initialDelaySeconds: 0
    periodSeconds: 10
    timeoutSeconds: 1
    failureThreshold: 3
 readinessProbe:
    httpGet:
      path: /weatherforecast
      port: http
    successThreshold: 3
...

Déployer votre chart Helm sur Kubernetes

À partir du répertoire charts\mymicroserviceapp dans le répertoire de la solution, exécutez la commande suivante :

helm upgrade --install mymicroserviceapp . --namespace=local --set mymicroserviceapp.image.tag="0.1.0"

Cette commande crée (ou met à niveau) une version existante à l’aide du nom dans l’espace local de noms mymicroserviceapp du cluster Kubernetes et génère une sortie similaire à cet exemple :

Release "mymicroserviceapp" does not exist. Installing it now.
NAME: mymicroserviceapp
LAST DEPLOYED: Fri Apr  2 08:47:24 2021
NAMESPACE: local
STATUS: deployed
REVISION: 1
NOTES:
1. Get the application URL by running these commands:
  export NODE_PORT=$(kubectl get --namespace local -o jsonpath="{.spec.ports[0].nodePort}" services mymicroserviceapp)
  export NODE_IP=$(kubectl get nodes --namespace local -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT

Après avoir déployé le graphique Helm, vous pouvez vérifier que les ressources ont été correctement déployées en exécutant kubectl get all -n local.

La sortie de l’exécution de la commande est la suivante :

NAME                                     READY   STATUS    RESTARTS   AGE
pod/mymicroserviceapp-7849f949df-fwgbn   1/1     Running   0          101s

NAME                        TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
service/mymicroserviceapp   NodePort   10.100.149.1   <none>        80:30501/TCP   101s

NAME                                READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/mymicroserviceapp   1/1     1            1           101s

NAME                                           DESIRED   CURRENT   READY   AGE
replicaset.apps/mymicroserviceapp-7849f949df   1         1         1       101s

Tester votre déploiement

L’application se déploie avec un service et un port de nœud ; vous pouvez donc appeler l’API à partir de l’extérieur du cluster. Pour effectuer cet appel, envoyez une requête à : http ://$NODE_IP :$NODE_PORT :

curl http://10.193.2.103:30501/WeatherForeCast/

StatusCode        : 200
StatusDescription : OK
Content           : [{"date":"2021-04-03T15:51:04.795216+00:00","temperatureC":45,"temperatureF":112,"summary":"Balmy"},{"date":"2021-04-04T15:51:04.
                    7952176+00:00","temperatureC":23,"temperatureF":73,"summary":"Cool"},{"...
RawContent        : HTTP/1.1 200 OK
                    Transfer-Encoding: chunked
                    Content-Type: application/json; charset=utf-8
                    Date: Fri, 02 Apr 2021 15:51:04 GMT
                    Server: Kestrel

                    [{"date":"2021-04-03T15:51:04.795216+00:00","tempera...
Forms             : {}
Headers           : {[Transfer-Encoding, chunked], [Content-Type, application/json; charset=utf-8], [Date, Fri, 02 Apr 2021 15:51:04 GMT], [Server,
                    Kestrel]}
Images            : {}
InputFields       : {}
Links             : {}
ParsedHtml        : mshtml.HTMLDocumentClass
RawContentLength  : 494

Nettoyer le cluster

La dernière étape consiste à nettoyer le cluster. Pour supprimer les ressources de déploiement Kubernetes, exécutez la commande suivante :

helm uninstall mymicroserviceapp -n local

Vous devez obtenir une sortie similaire à l’exemple suivant :

release "mymicroserviceapp" uninstalled

Étapes suivantes