Guide de démarrage rapide

Ce guide de démarrage rapide explique comment déployer une application conteneurisée avec Google Kubernetes Engine.

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

Procédez comme suit pour activer l'API Kubernetes Engine :
  1. Accédez à la page Kubernetes Engine dans la console Google Cloud Platform.
  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 Google Cloud Platform.

    Découvrir comment activer la facturation

Choisir une interface système

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

Google Cloud Shell est un environnement d'interface système permettant de gérer les ressources hébergées sur Google Cloud Platform (GCP). Cloud Shell est préinstallé avec les outils de ligne de commande gcloud et kubectl. L'outil gcloud est l'interface de ligne de commande utilisée sur GCP, tandis que kubectl fournit une interface permettant d'exécuter des commandes sur des clusters Kubernetes.

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

Cloud Shell

Pour lancer Cloud Shell, procédez comme suit :

  1. Accédez à la console Google Cloud Platform.

    Console Google Cloud Platform

  2. Dans le coin supérieur droit de la console, cliquez sur le bouton Activer Google Cloud Shell .

Une session Cloud Shell s'ouvre dans un cadre en bas de la console. Vous utiliserez cette interface système pour exécuter les commandes gcloud et kubectl.

Interface système locale

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

  1. Installez le SDK Google 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 pour gcloud

Avant de commencer, nous vous recommandons d'utiliser gcloud pour configurer deux paramètres par défaut : le projet et la 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 approximatif 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 en ajoutant des indicateurs opérationnels, tels que --project, --zone et --cluster, aux commandes gcloud.

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

Définir un projet par défaut

Pour définir un projet par défaut, exécutez la commande suivante à partir de Cloud Shell :

gcloud config set project [PROJECT_ID]

Remplacez [PROJECT_ID] par l'ID de votre projet.

Définir une zone de calcul par défaut

Pour définir une zone de calcul par défaut, exécutez la commande suivante :

gcloud config set compute/zone [COMPUTE_ZONE]

[COMPUTE_ZONE] est la zone de calcul géographique souhaitée, telle que us-west1-a.

Créer un cluster GKE

Un cluster contient au moins un système de cluster maître et plusieurs systèmes de calcul appelés nœuds. Les nœuds sont des instances de machine virtuelle (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.

Pour créer un cluster, exécutez la commande suivante :

gcloud container clusters create [CLUSTER_NAME]

[CLUSTER_NAME] est le nom que vous avez choisi pour le cluster.

Obtenir des informations d'authentification pour le cluster

Après avoir créé votre cluster, vous devez obtenir des identifiants pour interagir avec lui.

Afin de recevoir ces informations pour le cluster, exécutez la commande suivante :

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 les règles et l'équilibrage de charge pour l'accès à votre application depuis Internet.

Créer le déploiement

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

kubectl run hello-server --image gcr.io/google-samples/hello-app:1.0 --port 8080

La commande Kubernetes kubectl run crée un objet Déploiement nommé hello-server. Le pod de cet objet Déploiement exécute l'image hello-app dans son conteneur.

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 Google Container Registry, tandis que gcr.io/google-samples/hello-app:1.0 indique la version de l'image à extraire. Si aucune version n'est spécifiée, la plus récente est utilisée.
  • --port désigne le port que le conteneur expose.

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 :

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

L'indicateur --type LoadBalancer permet de créer un équilibreur de charge Compute Engine pour votre conteneur. L'indicateur --port initialise le port public 80 sur Internet et l'indicateur --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 l'objet Service hello-server en exécutant la commande kubectl get :

    kubectl get service hello-server

    Dans la sortie de cette commande, copiez l'adresse IP externe de l'objet Service, indiquée dans la colonne EXTERNAL-IP.

  2. Accédez à l'application depuis votre navigateur Web en spécifiant 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

Afin d'éviter que des frais ne soient facturés sur votre compte GCP pour les ressources utilisées dans ce guide de démarrage rapide, 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]

Facultatif : Examiner le code de 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 sous la forme d'une image de conteneur Docker. Les images de conteneur peuvent être stockées dans n'importe quel registre d'images Docker, tel que Google 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 implémentation de serveur Web écrite dans le langage de programmation Go. Le serveur répond à toutes les requêtes HTTP en affichant le message "Hello, World!".

package main

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

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

	// register hello function to handle all requests
	server := http.NewServeMux()
	server.HandleFunc("/", hello)

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

// 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

Le fichier 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 en savoir plus sur le fonctionnement de ce fichier, consultez la documentation de référence sur Dockerfile dans la documentation Docker.

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

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Kubernetes Engine