Déploiement d'une appli web conteneurisée sur Amazon EKS

GUIDE DE MISE EN ROUTE

Module 3 : créer votre déploiement

Dans ce module, vous créerez un déploiement et vous lancerez votre application.

Introduction

Dans ce module, vous créerez des configurations de service et de déploiement pour votre application à l'aide d'AWS CDK8S. Dans AWS CDK8S, les objets d'API Kubernetes sont représentés comme des structures. Ces structures peuvent être utilisées pour définir des services et des déploiements. La sortie générée par CDK8S est un fichier de configuration Kubernetes. Vous utiliserez la sortie de ce module et vous l'intégrerez au code AWS CDK des modules précédents pour déployer votre application.

Ce que vous apprendrez

  • Utiliser les structures CDK8S pour définir des objets d'API Kubernetes
  • Définir des services et des déploiements à l'aide de CDK8S
  • Générer des configurations Kubernetes à l'aide de CDK8S

 Durée

5 minutes

 Prérequis du module

  • Compte AWS avec accès administrateur**
  • Dernière version de Chrome ou de Firefox (recommandé)

[**] Les comptes créés dans les dernières 24 heures sont susceptibles de ne pas encore avoir accès aux services nécessaires pour ce didacticiel.

Implémentation

Définir l'application

À partir de cette étape, nous allons modifier main.py afin de définir l'application CDK8S. Le résultat devrait être le suivant après l'initialisation :

#!/usr/bin/env python
from constructs import Construct
from cdk8s import App, Chart

class MyChart(Chart):
    def __init__(self, scope: Construct, id: str):
        super().__init__(scope, id)

        # define resources here

app = App()
MyChart(app, "cdk8s")

app.synth()

Afin de déployer votre application, vous devez suivre 4 étapes :

  1. Importez la bibliothèque k8s afin de générer les chaînes pour le fichier de configuration Yaml.
  2. Définissez l'étiquette à appliquer aux pods à utiliser dans la recherche du service.
  3. Définissez un déploiement : cela va lancer le conteneur sur le cluster, mais pas le configurer pour qu'il reçoive du trafic depuis l'équilibreur de charge.
  4. Définissez un service pour exposer le déploiement vers l'équilibreur de charge.

Les étiquettes sont des paires clé/valeur attachées aux objets Kubernetes. Dans le cadre du déploiement, vous allez étiqueter les pods pour les exécuter. Le contrôleur de réplication utilisera les mêmes étiquettes pour sélectionner les pods lors de la création du service, afin de les exposer à l'équilibreur de charge. Vous utilisez le code label = {"app": "cdk8s"} pour ce faire.

Vous utiliserez ensuite ces étiquettes dans le déploiement. Dans Kubernetes, un déploiement est une déclaration explicite sur les unités de déploiement et l'état souhaité. Ce guide utilisera un exemple d'application hébergé dans Amazon ECR Public Gallery. L'URL de l'image de conteneur que nous allons extraire est public.ecr.aws/s9u7u6x1/sample app 001:no-db.

Afin de créer le déploiement et le service, mettez à jour main.py en ajoutant from imports import k8s en haut du fichier sous les autres importations, et en collant ici le code sous # define resources. Votre fichier devrait ressembler à ceci :

#!/usr/bin/env python
from constructs import Construct
from cdk8s import App, Chart
from imports import k8s

class MyChart(Chart):
    def __init__(self, scope: Construct, id: str):
        super().__init__(scope, f"{id}-deployment")

        # define resources here

        # Label used for tagging pods to link in the service
        label = {"app": "cdk8s"}

        # Creates the deployment to spin up pods with your container
        k8s.KubeDeployment(self, 'deployment',
            spec=k8s.DeploymentSpec(
                replicas=2,
                selector=k8s.LabelSelector(match_labels=label),
                template=k8s.PodTemplateSpec(
                metadata=k8s.ObjectMeta(labels=label),
                spec=k8s.PodSpec(containers=[
                    k8s.Container(
                    name='cdk8s',
                    image='public.ecr.aws/s9u7u6x1/sample_app_001:no-db',
                    ports=[k8s.ContainerPort(container_port=80)])]))))

        # Creates the service to expose the pods to traffic from the loadbalancer
        super().__init__(scope, f"{id}-service")
        k8s.KubeService(self, 'service',
            spec=k8s.ServiceSpec(
            type='LoadBalancer',
            ports=[k8s.ServicePort(port=80, target_port=k8s.IntOrString.from_number(80))],
            selector=label))

app = App()
MyChart(app, "cdk8s")

app.synth()

Vous remarquerez qu'un appel vers super() est effectué deux fois dans le cadre de cette méthode. Il crée le fichier Yaml avec le nom spécifié et ajoute toute configuration générée ultérieurement en appelant le constructeur de classe parent dont cette classe hérite. Cela générera un fichier pour la configuration du service ainsi qu'un fichier pour le déploiement. 

Vous pouvez désormais exécuter cdk8s synth afin de générer les fichiers de configuration, le résultat se présentera comme suit :

cdk8s synth

dist/cdk8s-deployment.k8s.yaml
dist/cdk8s-service.k8s.yaml

Conclusion

Dans ce module, vous avez découvert comment générer des fichiers de configuration Kubernetes à l'aide de CDK8S. Votre application est divisée entre un déploiement et un service, chacun disposant de son propre fichier de configuration.

Vous êtes désormais en mesure de mettre à jour le projet CDK afin de référencer ces fichiers et d'utiliser kubectl afin de les déployer vers le cluster EKS.

À suivre : déployer avec CDK

Dites-nous si nous avons répondu à vos attentes.