Démarrage rapide

Ce guide de démarrage rapide vous explique comment déployer une application conteneurisée de serveur Web simple sur un cluster Google Kubernetes Engine (GKE). Vous apprendrez à créer un cluster sur lequel déployer l'application pour qu'elle soit accessible aux utilisateurs.

Ce guide part du principe que vous avez déjà acquis les connaissances de base sur Kubernetes.

Vous pouvez suivre les étapes décrites sur cette page ou essayer ce démarrage rapide en tant qu'atelier de formation Google Cloud.

Essayer avec un atelier

Avant de commencer

Pour activer l'API Kubernetes Engine, procédez comme suit :

1. Accédez à la page Kubernetes Engine dans Google Cloud Console.
2. Créez ou sélectionnez un projet.
3. Patientez le temps de l'activation de l'API et des services associés. Cette opération peut prendre plusieurs minutes.

4. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Exigences en matière de quota

Pour effectuer ce démarrage rapide, vous avez besoin de quota disponible pour :

• un processeur Compute Engine situé dans la région de votre cluster ;
• une adresse IP en cours d'utilisation.

Vérifiez votre quota disponible à l'aide de Cloud Console.

Choisir une interface système

Pour effectuer ce démarrage rapide, vous pouvez utiliser Cloud Shell ou votre interface système locale.

Cloud Shell est un environnement shell permettant de gérer les ressources hébergées sur Google Cloud. Cloud Shell est préinstallé avec l'outil de ligne de commande gcloud et l'outil de ligne de commande kubectl. L'outil gcloud est l'interface de ligne de commande principale utilisée sur Google Cloud, et kubectl fournit l'interface de ligne de commande principale permettant d'exécuter des commandes sur les clusters Kubernetes.

Si vous préférez utiliser votre interface système locale, vous devez installer les outils gcloud et kubectl dans votre environnement.

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit :

1. Accédez à Google Cloud Console.

   Google Cloud Console

2. Dans l'angle supérieur droit de la console, cliquez sur le bouton Activer Cloud Shell :

Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console. Cette interface système vous permet d'exécuter les commandes gcloud et kubectl.

Interface système locale

Pour installer gcloud et kubectl, procédez comme suit :

1. Installez le SDK Cloud, qui inclut l'outil de ligne de commande gcloud.

2. Après avoir installé le SDK Cloud, installez l'outil de ligne de commande kubectl en exécutant la commande suivante :

   gcloud components install kubectl

Configurer les paramètres par défaut de l'outil gcloud

Utilisez l'outil gcloud pour configurer deux paramètres par défaut : votre projet et votre zone de calcul.

Votre projet est doté d'un ID de projet, qui constitue son identifiant unique. Au moment de la création d'un projet, vous pouvez utiliser l'ID de projet généré automatiquement ou créer le vôtre.

Votre zone de calcul est un emplacement régional dans lequel résident vos clusters et leurs ressources. Par exemple, us-west1-a est une zone de la région us-west.

La configuration de ces paramètres par défaut facilite l'exécution des commandes gcloud, car gcloud vous demanderait sinon de spécifier à chaque fois le projet et la zone de calcul dans lesquels vous souhaitez travailler. Vous pouvez également spécifier ces paramètres ou ignorer les paramètres par défaut à l'aide d'options, telles que --project, --zone et --cluster dans vos commandes gcloud.

Lorsque vous créez des ressources GKE après avoir configuré votre projet et votre zone de calcul par défaut, ces ressources sont automatiquement créées dans le projet et la zone spécifiés.

Remarque : L'outil gcloud peut renvoyer une erreur si ces paramètres ne sont pas configurés ou ne sont pas spécifiés.

Définir un projet par défaut

Exécutez la commande suivante en remplaçant project-id par l'ID de votre projet :

gcloud config set project project-id

Définir une zone de calcul par défaut

Exécutez la commande suivante en remplaçant compute-zone par votre zone de calcul, telle que us-west1-a :

gcloud config set compute/zone compute-zone

Créer un cluster GKE

Un cluster contient au moins un plan de contrôle de cluster et plusieurs systèmes de calcul appelés nœuds. Les nœuds sont des instances de machines virtuelles (VM) Compute Engine qui exécutent les processus Kubernetes nécessaires pour faire partie du cluster. Vous déployez les applications sur des clusters, et ces applications s'exécutent sur les nœuds.

La commande suivante crée un cluster à nœud unique. Remplacez cluster-name par le nom de votre cluster :

gcloud container clusters create cluster-name --num-nodes=1

Remarque : La création du cluster peut prendre plusieurs minutes.

Obtenir des informations d'authentification pour le cluster

Après avoir créé votre cluster, vous devez obtenir des informations d'authentification pour interagir avec lui :

gcloud container clusters get-credentials cluster-name

Cette commande configure kubectl pour l'utilisation du cluster que vous avez créé.

Déployer une application dans le cluster

Maintenant que vous avez créé un cluster, vous pouvez y déployer une application conteneurisée. Pour ce guide de démarrage rapide, vous pouvez déployer notre exemple d'application Web hello-app.

GKE utilise des objets Kubernetes pour créer et gérer les ressources de votre cluster. Kubernetes fournit l'objet Déploiement pour le déploiement d'applications sans état comme les serveurs Web. Les objets Service définissent des règles et gèrent l'équilibrage de charge pour accéder à votre application depuis Internet.

Créer le déploiement

Pour exécuter hello-app dans votre cluster, exécutez la commande suivante :

kubectl create deployment hello-server --image=gcr.io/google-samples/hello-app:1.0

Cette commande Kubernetes, kubectl create deployment, crée un déploiement nommé hello-server. Le pod de ce déploiement exécute l'image de conteneur hello-app.

Dans cette commande :

• --image désigne une image de conteneur à déployer. Dans cet exemple, la commande extrait l'exemple d'image d'un bucket Container Registry, gcr.io/google-samples/hello-app. :1.0 indique la version de l'image à extraire. Si vous ne spécifiez pas de version, la dernière version est utilisée.

Remarque : Dans ce tutoriel, vous utilisez une image de conteneur de Container Registry. Google Cloud fournit également un service de gestion de packages universel, Artifact Registry. Artifact Registry est compatible avec les conteneurs et d'autres formats, et offre une plus grande flexibilité et un meilleur contrôle des artefacts. Pour en savoir plus sur les différences entre ces registres, consultez la page Comparaison des fonctionnalités.

Exposer le déploiement

Après avoir déployé l'application, vous devez l'exposer sur Internet afin que les utilisateurs puissent y accéder. Vous pouvez exposer cette application en créant un objet Service, c'est-à-dire une ressource Kubernetes permettant d'exposer votre application au trafic externe.

Pour exposer votre application, exécutez la commande kubectl expose suivante :

kubectl expose deployment hello-server --type LoadBalancer \
  --port 80 --target-port 8080

L'option --type LoadBalancer permet de créer un équilibreur de charge Compute Engine pour votre conteneur. L'option --port initialise le port public 80 sur Internet et l'option --target-port achemine le trafic vers le port 8080 de l'application.

Les équilibreurs de charge sont facturés selon la tarification des équilibreurs de charge de Compute Engine.

Inspecter et visualiser l'application

1. Inspectez les pods en cours d'exécution à l'aide de la commande kubectl get pods :

   kubectl get pods

   Vous devriez voir un pod hello-server s'exécuter sur votre cluster.

2. Inspectez le service hello-server à l'aide de la commande kubectl get service :

   kubectl get service hello-server

   À partir du résultat de cette commande, copiez l'adresse IP externe du service depuis la colonne EXTERNAL-IP.

   Remarque : Vous devrez peut-être attendre quelques minutes avant que l'adresse IP externe de l'objet Service ne soit renseignée. Si l'adresse IP externe de l'application possède l'état <pending>, exécutez à nouveau kubectl get.

3. Consultez l'application dans votre navigateur Web à l'aide de l'adresse IP externe avec le port exposé :

   http://external-ip/

Vous venez de déployer une application Web conteneurisée sur GKE !

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce guide de démarrage rapide soient facturées sur votre compte Google Cloud, procédez comme suit :

1. Supprimez l'objet Service de l'application en exécutant la commande kubectl delete :

   kubectl delete service hello-server

   Cette commande supprime l'équilibreur de charge Compute Engine que vous avez créé lorsque vous avez exposé le déploiement.

2. Supprimez votre cluster en exécutant la commande gcloud container clusters delete :

   gcloud container clusters delete cluster-name

   Remarque : Si vous n'avez pas défini une zone ou une région par défaut, transmettez options de la région (--region=region ) ou de la zone (--zone=zone) du cluster à l'outil gcloud.

Facultatif : examen du code de l'application hello-app

hello-app est une application de serveur Web simple composée de deux fichiers : main.go et Dockerfile.

hello-app est packagée comme une image de conteneur Docker. Les images de conteneur peuvent être stockées dans n'importe quel registre d'images Docker, tel que Container Registry. Nous hébergeons hello-app dans un bucket Container Registry nommé gcr.io/google-samples/hello-app.

main.go

main.go correspond à une mise en œuvre de serveur Web écrite dans le langage de programmation Go. Le serveur répond à toutes les requêtes HTTP avec le message "Hello, world!"

hello-app/main.go

Afficher sur GitHub

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Dockerfile

Dockerfile décrit l'image que Docker doit générer, y compris toutes ses ressources et dépendances, et spécifie le port réseau que l'application doit exposer. Pour plus d'informations sur le fonctionnement de ce fichier, consultez le document de référence Dockerfile dans la documentation de Docker.

hello-app/Dockerfile

Afficher sur GitHub

FROM golang:1.8-alpine
ADD . /go/src/hello-app
RUN go install hello-app

FROM alpine:latest
COPY --from=0 /go/bin/hello-app .
ENV PORT 8080
CMD ["./hello-app"]

Étapes suivantes

• Apprenez-en plus sur la création de clusters.
• Apprenez-en plus sur Kubernetes.
• Consultez la documentation de référence sur kubectl.
• Apprenez à packager, héberger et déployer une application de serveur Web simple.
• Déployez une application Guestbook avec Redis et PHP.
• Déployez une application avec état WordPress offrant un stockage et une base de données MySQL persistants.