Implementare un'applicazione Web basata sui container con Amazon EKS

GUIDA ALLE OPERAZIONI DI BASE

Modulo 3: Creare la tua implementazione

In questo modulo, creerai un'implementazione tramite l'uso e l'avvio della tua applicazione

Introduzione

In questo modulo, creerai configurazioni di servizi e implementazioni per la tua applicazione utilizzando AWS CDK8s. In AWS CDK8s, gli oggetti delle API Kubernetes sono rappresentati come costrutti. Possiamo utilizzare quest'ultimi per definire servizi e implementazioni. L'output generato da CDK8s è un file config Kubernetes. Userai l'output di questo modulo e lo integrerai con il codice AWS CDK dei moduli precedenti per implementare la tua applicazione.

Cosa imparerai

  • Utilizzo dei costrutti CDK8s per definire gli oggetti delle API Kubernetes
  • Definizione dei servizi e delle implementazioni tramite CDK8s
  • Generazione di config Kubernetes tramite CDK8s

 Tempo richiesto per il completamento

5 minuti

 Prerequisiti del modulo

  • Account AWS con accesso da amministratore**
  • Browser consigliato: l'ultima versione di Chrome o Firefox

[**]Gli account creati nelle ultime 24 ore potrebbero non avere ancora accesso a tutti servizi richiesti per questo tutorial.

Implementazione

Definizione dell'applicazione

Da questo passaggio modificheremo main.py per definire l'applicazione CDK8s. Dovrebbe avere questo aspetto dopo l'inizializzazione:

#!/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()

Per implementare la tua applicazione, sono 4 i passaggi da seguire:

  1. Importa la libreria k8s per aiutare a generare le stringhe per il file config Yaml.
  2. Definisci il set di etichette da applicare ai pod per utilizzarle nella ricerca dei servizi.
  3. Definisci un'implementazione - il container sul cluster si avvierà, ma non verrà configurato per ricevere il traffico dal bilanciatore del carico.
  4. Definisci un servizio per esporre l'implementazione al bilanciatore del carico.

Le etichette sono coppie chiave/valore allegate agli oggetti Kubernetes. Aggiungerai tag ai pod come parte dell'implementazione per eseguirli, e il ReplicationController farà uso delle stesse etichette per selezionare i pod durante la creazione del servizio per esporli al bilanciatore del carico. Per fare ciò, utilizza il codice etichetta = {"app": "cdk8s"}.

Userai quindi queste etichette per l'implementazione. Un'implementazione in Kubernetes è una dichiarazione esplicita sulle unità di implementazione e lo stato desiderato. Questa guida farà uso di un'applicazione esemplificativa ospitata sulla galleria pubblica di Amazon ECR. L'URL per l'immagine del container che andremo a estrarre è public.ecr.aws/s9u7u6x1/sample app 001:no-db.

Per creare l'implementazione e il servizio, aggiorna main.py aggiungendo from imports import k8s all'inizio del file sotto le altre importazioni, e incollando il seguente codice qui sotto # define resources here. Il tuo file dovrebbe ora avere questo aspetto:

#!/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()

Noterai che in questo metodo viene effettuata due volte una chiamata a super(). Questo crea il file Yaml con il nome specificato e aggiunge eventuali config generate dopo quel punto chiamando il costruttore della classe genitore da cui questa classe eredita. Questo genererà un file per la config del servizio e un secondo file per l'implementazione. 

Ora puoi eseguire cdk8s synth per generare i file config. L'ouput avrà questo aspetto:

cdk8s synth

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

Conclusione

In questo modulo, hai imparato come generare file di configurazione di Kubernetes tramite CDK8s. La tua applicazione è divisa in un'implementazione e in un servizio, ognuno con il proprio file config.

Ora sei pronto ad aggiornare il progetto CDK per fare riferimento a questi file e usare kubectl per implementarli nel cluster EKS.

A seguire: Implementazione con CDK

Facci sapere com'è andata.

Grazie per il tuo feedback
Siamo contenti che questa pagina ti sia stata d’aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi
Grazie per il tuo feedback
Ci dispiace che questa pagina non ti sia stata d'aiuto. Vuoi condividere ulteriori dettagli per aiutarci a continuare a migliorare?
Chiudi