TOC

Comment déployer une application résiliente Go sur DigitalOcean Kubernetes

L’auteur a sélectionné Girls Who Code pour recevoir un don dans le cadre du programme Write for DOnations .

introduction

Docker est un outil containerization utilisé pour fournir aux applications un système de fichiers contenant tout ce dont elles ont besoin pour s’exécuter, garantissant que le logiciel disposera d’un environnement d’exécution cohérent et se comportera de la même manière, quel que soit le lieu où il est déployé. Kubernetes est une plate-forme cloud permettant d’automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées.

En tirant parti de Docker, vous pouvez déployer une application sur n’importe quel système prenant en charge Docker avec la certitude que celle-ci fonctionnera toujours comme prévu. Kubernetes, quant à lui, vous permet de déployer votre application sur plusieurs nœuds d’un cluster. En outre, il gère des tâches clés telles que la création de nouveaux conteneurs en cas de blocage de l’un de vos conteneurs. Ensemble, ces outils rationalisent le processus de déploiement d’une application, vous permettant de vous concentrer sur le développement.

Dans ce didacticiel, vous allez construire un exemple d’application écrit à l’adresse Go et le lancer et le faire fonctionner localement sur votre ordinateur de développement. Vous allez ensuite conteneuriser l’application avec Docker, la déployer sur un cluster Kubernetes et créer un équilibreur de charge qui servira de point d’entrée public pour votre application.

Conditions préalables

Avant de commencer ce tutoriel, vous aurez besoin des éléments suivants:

  • Un serveur de développement ou une machine locale à partir de laquelle vous déploierez l’application. Bien que les instructions de ce guide fonctionnent principalement pour la plupart des systèmes d’exploitation, ce didacticiel suppose que vous avez accès à un système Ubuntu 18.04 configuré avec un utilisateur non root avec les privilèges sudo, comme décrit dans notre https://www.digitalocean.com. / community / tutorials / initial-server-setup-with-ubuntu-18-04 Didacticiel [Configuration initiale du serveur pour Ubuntu 18.04].

  • L’outil de ligne de commande + docker + installé sur votre ordinateur de développement. Pour l’installer, suivez les * Étapes 1 et 2 * de notre tutoriel à l’adresse How installer et utiliser Docker sur Ubuntu 18.04.

  • L’outil de ligne de commande + kubectl + installé sur votre ordinateur de développement. Pour l’installer, suivez this guide de la documentation officielle de Kubernetes.

  • Un compte gratuit sur Docker Hub sur lequel vous allez pousser votre image Docker. Pour configurer cela, visitez le site Web Docker Hub, cliquez sur le bouton * Commencer * en haut à droite de la page et suivez les instructions d’enregistrement.

  • Un cluster Kubernetes. Vous pouvez provisionner un cluster DigitalOcean Kubernetes en suivant notre Kubernetes Guide de démarrage rapide. Vous pouvez toujours terminer ce didacticiel si vous configurez votre cluster à partir d’un autre fournisseur de cloud. Où que vous achetiez votre cluster, veillez à configurer un fichier de configuration et à vous connecter au cluster à partir de votre serveur de développement.

Étape 1 - Construction d’un exemple d’application Web en Go

Dans cette étape, vous allez créer un exemple d’application écrit en Go. Une fois que vous avez conteneurisé cette application avec Docker, il servira + My Awesome Go App + en réponse aux demandes adressées à l’adresse IP de votre serveur sur le port + 3000 +.

Commencez par mettre à jour les listes de paquets de votre serveur si vous ne l’avez pas fait récemment:

sudo apt update

Puis installez Go en lançant:

sudo apt install golang

Ensuite, assurez-vous que vous êtes dans votre répertoire personnel et créez un nouveau répertoire qui contiendra tous vos fichiers de projet:

cd && mkdir go-app

Ensuite, accédez à ce nouveau répertoire:

cd go-app/

Utilisez + nano + ou votre éditeur de texte préféré pour créer un fichier nommé + main.go + qui contiendra le code de votre application Go:

nano main.go

La première ligne de tout fichier source Go est toujours une instruction + package + qui définit le groupe de codes auquel le fichier appartient. Pour les fichiers exécutables comme celui-ci, l’instruction + package doit pointer vers le paquet` + main`:

go-app / main.go

Ensuite, ajoutez une instruction + import dans laquelle vous pouvez répertorier toutes les bibliothèques dont l’application aura besoin. Ici, incluez + fmt +, qui gère les entrées et les sorties de texte formatées, et + net / http +, qui fournit les implémentations client et serveur HTTP:

go-app / main.go

package main

Ensuite, définissez une fonction + homePage + qui prendra deux arguments: + http.ResponseWriter + et un pointeur sur + http.Request +. En Go, une interface + ResponseWriter est utilisée pour construire une réponse HTTP, tandis que` + http.Request` est un objet représentant une demande entrante. Ainsi, ce bloc lit les requêtes HTTP entrantes puis construit une réponse:

go-app / main.go

. . .

import (
 "fmt"
 "net/http"
)

Après cela, ajoutez une fonction + setupRoutes + qui mappera les demandes entrantes aux fonctions de gestionnaire HTTP prévues. Dans le corps de cette fonction + setupRoutes +, ajoutez un mappage de la route + / + à votre nouvelle fonction + homePage +. Cela indique à l’application d’imprimer le message + My Awesome Go App + même pour les demandes adressées à des noeuds finaux inconnus:

go-app / main.go

. . .

func homePage(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "My Awesome Go App")
}

Et enfin, ajoutez la fonction + main + suivante. Cela affichera une chaîne indiquant que votre application a démarré. Il appellera ensuite la fonction + setupRoutes + avant d’écouter et de servir votre application Go sur le port + 3000 +.

go-app / main.go

. . .

func setupRoutes() {
 http.HandleFunc("/", homePage)
}

Après avoir ajouté ces lignes, voici à quoi ressemblera le fichier final:

go-app / main.go

package main

import (
 "fmt"
 "net/http"
)

func homePage(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "My Awesome Go App")
}

func setupRoutes() {
 http.HandleFunc("/", homePage)
}

func main() {
 fmt.Println("Go Web App Started on Port 3000")
 setupRoutes()
 http.ListenAndServe(":3000", nil)
}

Enregistrez et fermez ce fichier. Si vous avez créé ce fichier en utilisant + nano +, faites-le en pressant + CTRL + X +, + Y +, puis + ENTER +.

Ensuite, exécutez l’application à l’aide de la commande + go run + suivante. Ceci compilera le code dans votre fichier + main.go + et l’exécutera localement sur votre machine de développement:

go run main.go
OutputGo Web App Started on Port 3000

Cette sortie confirme que l’application fonctionne comme prévu. Il fonctionnera indéfiniment, mais fermez-le en appuyant sur + CTRL + C +.

Tout au long de ce guide, vous allez utiliser cet exemple d’application pour expérimenter Docker et Kubernetes. Pour ce faire, continuez à lire pour apprendre à conteneuriser votre application avec Docker.

Étape 2 - Application Dockerizing Your Go

Dans son état actuel, l’application Go que vous venez de créer ne s’exécute que sur votre serveur de développement. Au cours de cette étape, vous allez rendre cette nouvelle application portable en la conteneurisant avec Docker. Cela lui permettra de fonctionner sur n’importe quel ordinateur prenant en charge les conteneurs Docker. Vous allez créer une image Docker et la placer dans un référentiel public central sur Docker Hub. De cette manière, votre cluster Kubernetes peut redimensionner l’image et la déployer en tant que conteneur au sein du cluster.

La première étape vers la conteneurisation de votre application consiste à créer un script spécial appelé Dockerfile. Un fichier Docker contient généralement une liste d’instructions et d’arguments qui s’exécutent dans un ordre séquentiel afin d’effectuer automatiquement certaines actions sur une image de base ou d’en créer une nouvelle.

Créez un nouveau fichier nommé + Dockerfile +:

nano Dockerfile

En haut du fichier, spécifiez l’image de base nécessaire pour l’application Go:

go-app / Dockerfile

Créez ensuite un répertoire + app + dans le conteneur qui contiendra les fichiers source de l’application:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9

En-dessous, ajoutez la ligne suivante, qui copie tout le contenu du répertoire + root + dans le répertoire + app +:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app

Ensuite, ajoutez la ligne suivante qui modifie le répertoire de travail en + app +, ce qui signifie que toutes les commandes suivantes de ce fichier Docker seront exécutées à partir de cet emplacement:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app

Ajoutez une ligne demandant à Docker d’exécuter la commande + go build -o main +, qui compile l’exécutable binaire de l’application Go:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app
WORKDIR /app

Ajoutez ensuite la dernière ligne qui exécutera l’exécutable binaire:

go-app / Dockerfile

FROM golang:1.12.0-alpine3.9
RUN mkdir /app
ADD . /app
WORKDIR /app
RUN go build -o main .

Enregistrez et fermez le fichier après avoir ajouté ces lignes.

Maintenant que vous avez ce + Dockerfile + à la racine de votre projet, vous pouvez créer une image Docker à partir de celle-ci en utilisant la commande + docker build + suivante. Cette commande inclut l’indicateur + -t + qui, une fois passé la valeur + go-web-app +, nommera l’image de Docker + go-web-app + et tag it.

Le dernier argument que vous allez passer est le chemin: +. +. Cela indique que vous souhaitez créer l’image Docker à partir du contenu du répertoire de travail actuel. Assurez-vous également de mettre à jour ++ avec votre nom d’utilisateur Docker Hub:

docker build -t /go-web-app .

Cette commande de construction lira toutes les lignes de votre + Dockerfile +, les exécutera dans l’ordre, puis les mettra en cache, ce qui permettra aux futures générations d’exécuter beaucoup plus rapidement:

Output. . .
Successfully built
Successfully tagged go-web-app:latest

Une fois que cette commande a fini de la construire, vous pourrez voir votre image lorsque vous exécuterez la commande + docker images + comme ceci:

docker images
OutputREPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
/go-web-app   latest                      3 seconds ago       355MB

Ensuite, utilisez la commande suivante pour créer et démarrer un conteneur en fonction de l’image que vous venez de créer. Cette commande inclut l’indicateur + -it +, qui spécifie que le conteneur s’exécutera en mode interactif. Il contient également l’indicateur + -p + qui mappe le port sur lequel l’application Go est exécutée sur votre ordinateur de développement - le port + 3000 + - au port + 3000 + de votre conteneur Docker:

docker run -it -p 3000:3000 /go-web-app
OutputGo Web App Started on Port 3000

Si rien ne fonctionne sur ce port, vous pourrez voir l’application en action en ouvrant un navigateur et en vous dirigeant vers l’URL suivante:

http://:3000

image: https: //assets.digitalocean.com/articles/resilient_go_kubernetes/resilient_screenshot_1.png [Votre application Go conteneurisée]

Après avoir vérifié que l’application fonctionne comme prévu dans votre navigateur, arrêtez-la en appuyant sur les touches + CTRL + C + de votre terminal.

Lorsque vous déployez votre application conteneurisée sur votre cluster Kubernetes, vous devez être en mesure d’extraire l’image à partir d’un emplacement centralisé. À cette fin, vous pouvez transférer votre image nouvellement créée vers votre référentiel d’images Docker Hub.

Exécutez la commande suivante pour vous connecter à Docker Hub depuis votre terminal:

docker login

Cela vous demandera votre nom d’utilisateur et votre mot de passe Docker Hub. Après les avoir entrées correctement, vous verrez "+ Login Succeeded +" dans la sortie de la commande.

Une fois connecté, placez votre nouvelle image sur Docker Hub à l’aide de la commande + docker push +, comme suit:

docker push /go-web-app

Une fois cette commande exécutée avec succès, vous pourrez ouvrir votre compte Docker Hub et y voir votre image Docker.

Maintenant que vous avez déplacé votre image vers un emplacement central, vous êtes prête à la déployer sur votre cluster Kubernetes. Tout d’abord, cependant, nous allons parcourir un bref processus qui rendra beaucoup moins fastidieuse l’exécution de commandes + kubectl +

Étape 3 - Améliorer la convivialité pour + kubectl +

À ce stade, vous avez créé une application Go fonctionnelle et l’a conteneurisée avec Docker. Cependant, l’application n’est toujours pas accessible au public. Pour résoudre ce problème, vous allez déployer votre nouvelle image Docker sur votre cluster Kubernetes à l’aide de l’outil de ligne de commande + kubectl +. Avant de faire cela, cependant, modifions légèrement le fichier de configuration de Kubernetes, ce qui contribuera à simplifier l’exécution des commandes + kubectl +.

Par défaut, lorsque vous exécutez des commandes avec l’outil de ligne de commande + kubectl +, vous devez spécifier le chemin du fichier de configuration du cluster à l’aide de l’indicateur + - kubeconfig +. Cependant, si votre fichier de configuration s’appelle + config + et est stocké dans un répertoire nommé + ~ / .kube +, + kubectl + saura où chercher le fichier de configuration et pourra le récupérer sans le ` + - kubeconfig + `le drapeau pointant dessus.

À cette fin, si ce n’est déjà fait, créez un nouveau répertoire appelé + ~ / .kube +:

mkdir ~/.kube

Déplacez ensuite votre fichier de configuration du cluster dans ce répertoire et renommez-le + config + dans le processus:

mv .yaml ~/.kube/config

À l’avenir, vous n’aurez pas besoin de spécifier l’emplacement du fichier de configuration de votre cluster lorsque vous exécuterez + kubectl +, car la commande pourra le trouver maintenant qu’il se trouve à l’emplacement par défaut. Testez ce comportement en exécutant la commande + get nodes + suivante:

kubectl get nodes

Cela affichera tous les nodes qui résident dans votre cluster Kubernetes. Dans le contexte de Kubernetes, un nœud est un serveur ou un ordinateur de travail sur lequel un ou plusieurs pods peuvent être déployés:

OutputNAME                                        STATUS    ROLES     AGE       VERSION
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfd   Ready     <none>    1m        v1.13.5
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfi   Ready     <none>    1m        v1.13.5
k8s-1-13-5-do-0-nyc1-1554148094743-1-7lfv   Ready     <none>    1m        v1.13.5

Avec cela, vous êtes prêt à déployer votre application sur votre cluster Kubernetes. Pour ce faire, vous devez créer deux objets Kubernetes: un qui déploiera l’application sur certains pods de votre cluster et un autre qui créera un équilibreur de charge fournissant un point d’accès à votre application.

Étape 4 - Création d’un déploiement

RESTful resources constituent toutes les entités persistantes dans un système Kubernetes et, dans ce contexte, elles sont communément appelées objets Kubernetes. Pensez aux objets Kubernetes comme aux ordres de travail que vous soumettez à Kubernetes: indiquez les ressources dont vous avez besoin et leur fonctionnement, puis Kubernetes travaillera en permanence pour s’assurer qu’elles existent dans votre cluster.

Un type d’objet Kubernetes, appelé deployment, est un ensemble de pods identiques et indiscernables. Dans Kubernetes, un pod est un groupe d’un ou de plusieurs conteneurs pouvant communiquer sur le même réseau partagé et interagir avec le même stockage partagé. . Un déploiement exécute plusieurs répliques de l’application parent à la fois et remplace automatiquement toutes les instances qui échouent, garantissant ainsi que votre application est toujours disponible pour répondre aux demandes des utilisateurs.

Dans cette étape, vous allez créer un fichier de description d’objet Kubernetes, également appelé manifest, pour un déploiement. Ce manifeste contiendra tous les détails de configuration nécessaires au déploiement de votre application Go sur votre cluster.

Commencez par créer un manifeste de déploiement dans le répertoire racine de votre projet: + go-app / +. Pour de petits projets tels que celui-ci, les conserver dans le répertoire racine minimise la complexité. Toutefois, pour les projets plus importants, il peut être avantageux de stocker vos manifestes dans un sous-répertoire distinct afin de tout organiser.

Créez un nouveau fichier nommé + deployment.yml +:

nano deployment.yml

Différentes versions de l’API Kubernetes contiennent différentes définitions d’objets. Vous devez donc définir le + apiVersion + que vous utilisez pour créer cet objet. Pour les besoins de ce didacticiel, vous utiliserez le groupe + apps / v1 + car il contient de nombreuses définitions d’objets Kubernetes de base dont vous aurez besoin pour créer un déploiement. Ajoutez un champ sous + apiVersion + décrivant le + kind + de l’objet Kubernetes que vous créez. Dans ce cas, vous créez un + déploiement +:

go-app / deployment.yml

Définissez ensuite le + métadonnées + pour votre déploiement. Un champ + métadonnées + est requis pour chaque objet Kubernetes car il contient des informations telles que le nom unique + nom + de l’objet. Ce + nom + est utile car il vous permet de distinguer différents déploiements les uns des autres et de les identifier à l’aide de noms lisibles par l’homme:

go-app / deployment.yml

---
apiVersion: apps/v1
kind: Deployment

Ensuite, vous allez construire le bloc + spec + de votre + deployment.yml +. Un champ + spec + est une exigence pour chaque objet Kubernetes, mais son format précis diffère pour chaque type d’objet. Dans le cas d’un déploiement, il peut contenir des informations telles que le nombre de répliques que vous souhaitez exécuter. Dans Kubernetes, une réplique correspond au nombre de pods que vous souhaitez exécuter dans votre cluster. Ici, définissez le nombre de + réplicas + sur + 5 +:

go-app / deployment.yml

. . .
metadata:
   name: go-web-app

Ensuite, créez un bloc + sélecteur + imbriqué sous le bloc + spec +. Cela servira de sélecteur de label pour vos pods. Kubernetes utilise des sélecteurs d’étiquettes pour définir comment le déploiement trouve les pods qu’il doit gérer.

Dans ce bloc + selector, définissez` + matchLabels` et ajoutez le libellé + name. Pour l’essentiel, le champ + matchLabels + indique à Kubernetes à quels pods le déploiement s’applique. Dans cet exemple, le déploiement s’appliquera à tous les pods portant le nom + go-web-app +:

go-app / deployment.yml

. . .
spec:
 replicas: 5

Après cela, ajoutez un bloc + template +. Chaque déploiement crée un ensemble de pods utilisant les étiquettes spécifiées dans un bloc + template +. Le premier sous-champ de ce bloc est + metadata + qui contient les + labels + qui seront appliqués à tous les pods de ce déploiement. Ces étiquettes sont des paires clé / valeur utilisées comme attributs d’identification d’objets Kubernetes. Lorsque vous définissez votre service ultérieurement, vous pouvez indiquer que vous souhaitez que tous les modules portant cette étiquette + name + soient regroupés sous ce service. Définissez ce libellé + name sur` + go-web-app`:

go-app / deployment.yml

. . .
spec:
 replicas: 5
 selector:
   matchLabels:
     name: go-web-app

La deuxième partie de ce bloc + template + est le bloc + spec +. Ceci est différent du bloc + spec + 'que vous avez ajouté précédemment, car celui-ci s’applique uniquement aux pods créés par le bloc + template + `, plutôt qu’à l’ensemble du déploiement.

Dans ce bloc + spec +, ajoutez un champ + conteneurs + et définissez à nouveau un attribut + nom +. Ce champ + name + définit le nom de tous les conteneurs créés par ce déploiement particulier. En-dessous, définissez le + image + que vous souhaitez extraire et déployer. Assurez-vous de changer ++ en votre propre nom d’utilisateur Docker Hub:

go-app / deployment.yml

. . .
 template:
   metadata:
     labels:
       name: go-web-app



       sammy

Après cela, ajoutez un champ + imagePullPolicy + défini sur + IfNotPresent + qui dirigera le déploiement pour extraire une image uniquement s’il ne l’a pas déjà fait auparavant. Enfin, ajoutez un bloc + ports +. Là, définissez le + conteneurPort + qui devrait correspondre au numéro de port que votre application Go écoute. Dans ce cas, le numéro de port est + 3000 +:

go-app / deployment.yml

. . .
   spec:
     containers:
     - name: application
       image: /go-web-app

La version complète de votre + deployment.yml + ressemblera à ceci:

go-app / deployment.yml

---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: go-web-app
spec:
 replicas: 5
 selector:
   matchLabels:
     name: go-web-app
 template:
   metadata:
     labels:
       name: go-web-app
   spec:
     containers:
     - name: application
       image: /go-web-app
       imagePullPolicy: IfNotPresent
       ports:
         - containerPort: 3000

Enregistrez et fermez le fichier.

Ensuite, appliquez votre nouveau déploiement avec la commande suivante:

kubectl apply -f deployment.yml

Dans l’étape suivante, vous créerez un autre type d’objet Kubernetes qui gérera le mode d’accès aux pods existant dans votre nouveau déploiement. Ce service créera un équilibreur de charge qui exposera ensuite une seule adresse IP et les demandes adressées à cette adresse IP seront distribuées aux réplicas de votre déploiement. Ce service gérera également les règles de transfert de port afin que vous puissiez accéder à votre application via HTTP.

Étape 5 - Création d’un service

Maintenant que le déploiement de Kubernetes est réussi, vous êtes prêt à exposer votre application au monde extérieur. Pour ce faire, vous devrez définir un autre type d’objet Kubernetes: un service. Ce service exposera le même port sur tous les nœuds de votre cluster. Vos nœuds transféreront ensuite tout le trafic entrant sur ce port aux pods exécutant votre application.

Créez un nouveau fichier nommé + service.yml +:

nano service.yml

Démarrez ce fichier en définissant à nouveau les champs + apiVersion + et + kind + de la même manière que votre fichier + deployment.yml +. Cette fois, pointez le champ + apiVersion + sur + v1 +, l’API Kubernetes couramment utilisée pour les services:

go-app / service.yml

Ensuite, ajoutez le nom de votre service dans un bloc + métadonnées + comme vous l’avez fait dans + deployment.yml +. Cela pourrait être ce que vous voulez, mais pour plus de clarté, nous appellerons cela + go-web-service +:

go-app / service.yml

---
apiVersion: v1
kind: Service

Ensuite, créez un bloc + spec +. Ce bloc + spec + sera différent de celui inclus dans votre déploiement et contiendra le + type + de ce service, ainsi que la configuration de la redirection de port et le + sélecteur +.

Ajoutez un champ définissant ce service + type et réglez-le sur` + Load Balancer`. Cela mettra automatiquement en service un équilibreur de charge qui agira comme point d’entrée principal de votre application.

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service

Ajoutez ensuite un bloc + ports + où vous définissez comment vous souhaitez que vos applications soient accessibles. Imbriquées dans ce bloc, ajoutez les champs suivants:

  • + nom +, pointant vers + http

  • + port +, pointant vers le port + 80 +

  • + targetPort +, pointant vers le port + 3000 +

Cela prendra les requêtes HTTP entrantes sur le port + 80 + et les transmettra au + targetPort + de + 3000 +. Ce + targetPort + est le même port sur lequel votre application Go est en cours d’exécution:

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service
spec:
 type: LoadBalancer

Enfin, ajoutez un bloc + selector comme vous l’avez fait dans le fichier` + deployment.yaml`. Ce bloc + selector est important, car il mappe tous les pods déployés nommés` + go-web-app` à ce service:

go-app / service.yml

---
apiVersion: v1
kind: Service
metadata:
 name: go-web-service
spec:
 type: LoadBalancer
 ports:
 - name: http
   port: 80
   targetPort: 3000

Après avoir ajouté ces lignes, enregistrez et fermez le fichier. Ensuite, appliquez ce service à votre cluster Kubernetes en utilisant à nouveau la commande + kubectl apply + de la manière suivante:

kubectl apply -f service.yml

Cette commande appliquera le nouveau service Kubernetes et créera un équilibreur de charge. Cet équilibreur de charge servira de point d’entrée public pour votre application s’exécutant dans le cluster.

Pour afficher l’application, vous aurez besoin de la nouvelle adresse IP de l’équilibreur de charge. Trouvez-le en lançant la commande suivante:

kubectl get services
OutputNAME             TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)        AGE
go-web-service   LoadBalancer   10.245.107.189      80:30533/TCP   10m
kubernetes       ClusterIP      10.245.0.1       <none>            443/TCP        3h4m

Vous pouvez avoir plusieurs services en cours d’exécution, mais trouvez celui qui s’appelle + go-web-service +. Recherchez la colonne + EXTERNAL-IP + et copiez l’adresse IP associée au service + go-web-service +. Dans cet exemple de sortie, cette adresse IP est ++. Ensuite, collez l’adresse IP dans la barre d’URL de votre navigateur pour afficher l’application en cours d’exécution sur votre cluster Kubernetes.

L’équilibreur de charge prendra la demande sur le port + 80 + et la transmettra à l’un des pods exécutés dans votre cluster.

image: https: //assets.digitalocean.com/articles/resilient_go_kubernetes/resilient_screenshot_2.png [Votre application fonctionne!]

Avec cela, vous avez créé un service Kubernetes associé à un équilibreur de charge, ce qui vous donne un point d’entrée unique et stable pour l’application.

Conclusion

Dans ce tutoriel, vous avez construit l’application Go, l’a conteneurisée avec Docker, puis l’a déployée dans un cluster Kubernetes. Vous avez ensuite créé un équilibreur de charge qui fournit un point d’entrée résilient à cette application, garantissant qu’il restera hautement disponible même en cas de défaillance d’un des nœuds de votre cluster. Vous pouvez utiliser ce didacticiel pour déployer votre propre application Go sur un cluster Kubernetes ou continuer à apprendre d’autres concepts Kubernetes et Docker avec l’exemple d’application créé à l’étape 1.

Pour aller de l’avant, vous pouvez mettre l’adresse IP de votre équilibreur de charge à un nom de domaine qui vous contrôlez pour pouvoir accéder à l’application via une adresse Web lisible par l’homme plutôt que par l’adresse IP de l’équilibreur de charge. De plus, les tutoriels suivants sur Kubernetes peuvent vous intéresser:

Enfin, si vous souhaitez en savoir plus sur Go, nous vous encourageons à consulter notre série sur Comment coder dans Aller.

Related