Kubernetes mediante Cloud Shell: distribuzione di un'applicazione Flask Python

In questa esercitazione viene utilizzato un account Oracle Cloud Infrastructure per impostare un cluster Kubernetes. Quindi, si crea un'applicazione Python con una struttura Flask. Infine, distribuire l'applicazione nel cluster utilizzando Cloud Shell.

I task chiave includono come:

  • Creare un compartimento.
  • Impostare un cluster Kubernetes su OCI.
  • Crea un'applicazione Python in una struttura Flask.
  • Crea un'immagine Docker.
  • Invia l'immagine a OCI Container Registry.
  • Utilizzare Cloud Shell per distribuire l'applicazione Docker nel cluster.
  • Connettersi all'applicazione da Internet.
Diagramma dei componenti necessari per eseguire un'applicazione Python, in un framework Flask, su Oracle Cloud Infrastructure Kubernetes Engine utilizzando Cloud Shell.

Per ulteriori informazioni, vedere:

Informazioni preliminari

Per eseguire correttamente questa esercitazione, è necessario disporre dei seguenti elementi:

Requisiti
  • Un account a pagamento Oracle Cloud Infrastructure. Vedere Iscrizione a Oracle Cloud Infrastructure.
  • Cloud Shell offre le applicazioni riportate di seguito.
    • JDK 8+
    • Python 3.6.8+
    • Kubectl 1.18.10+
    • Apache Maven 3.5+
    • Docker 19.0.11+
Nota

Il vantaggio di utilizzare Cloud Shell consiste nel fatto che tutti gli strumenti necessari per gestire l'applicazione sono già installati e pronti per l'uso.

1. Prepara

Preparare l'ambiente per creare e distribuire l'applicazione.

Controllare i limiti del servizio
  1. Accedi alla console di Oracle Cloud Infrastructure.
  2. Aprire il menu di navigazione e fare clic su Governance e amministrazione. In Governance fare clic su Limiti, quote e uso.
  3. Trova il limite del servizio per le aree:
    • Filtro per le seguenti opzioni:
      • Servizio: aree
      • Ambito: tenancy
      • Risorsa: conteggio aree sottoscritte
      • Compartimento: <tenancy-name> (radice)
    • Trova limite servizio:
      • Nome limite: subscribed-region-count
      • Limite servizio: minimo 2
  4. Trova il conteggio delle memorie centrali di Computazione disponibile per VM.Standard.E3. Forma Flex:
    • Filtro per le seguenti opzioni:
      • Servizio: Compute
      • Ambito: <first-availability-domain>. Esempio: EMlr:US-ASHBURN-AD-1
      • Risorsa: memorie per Standard.E3. Istanze Flex e BM.Standard.E3.128
      • Compartimento: <tenancy-name> (radice)
    • Trova conteggio memorie centrali disponibili:
      • Nome limite: standard-e3-core-ad-count
      • Disponibile: minimo 1
    • Ripetere l'operazione per Ambito: <second-availability-domain> e <third-availability-domain>. Ogni area deve avere almeno una memoria centrale disponibile per questa forma.
  5. Scopri se sono disponibili 50 GB di volume a blocchi:
    • Filtro per le seguenti opzioni:
      • Servizio: volume a blocchi
      • Ambito: <first-availability-domain>. Esempio: EMlr:US-ASHBURN-AD-1
      • Dimensione volume risorsa (GB)
      • Compartimento: <tenancy-name> (radice)
    • Trova conteggio memorie centrali disponibili:
      • Nome limite: total-storage-gb
      • Disponibile: minimo 50
    • Ripetere l'operazione per Ambito: <second-availability-domain> e <third-availability-domain>. Ogni area deve avere almeno 50 GB di volume a blocchi disponibili.
  6. Scopri quanti load balancer flessibili hai a disposizione:
    • Filtro per le seguenti opzioni:
      • Servizio: LbaaS
      • Ambito: <your-region>. Esempio: us-ashburn-1
      • Risorsa: <blank>
      • Compartimento: <tenancy-name> (radice)
    • Trovare il conteggio per le seguenti forme
      • Nome limite: lb-flexible-bandwidth-count
      • Disponibile: minimo 1
Nota

Questa esercitazione crea tre istanze di computazione con una forma VM.Standard.E2.1 per i nodi cluster. Per utilizzare un'altra forma, filtrare per il conteggio di memorie centrali. Ad esempio, per VM.Standard2.4, filtrare i memorie per le istanze VM e BM basate su Standard2 e ottenere il conteggio.

Per un elenco di tutte le forme, vedere Forme standard VM.

Nota

Questa esercitazione crea tre istanze di computazione con un file VM.Standard.E3. Forma Flex per i nodi cluster. Per utilizzare un'altra forma, filtrare per il conteggio di memorie centrali. Ad esempio, per VM.Standard2.4, filtrare i memorie per le istanze VM e BM basate su Standard2 e ottenere il conteggio.

Per un elenco di tutte le forme, vedere Forme standard VM.

Nota

Questa esercitazione utilizza un workflow 'Creazione rapida' per creare un cluster con una subnet regionale pubblica che ospita un load balancer flessibile. Per utilizzare un load balancer diverso, è possibile utilizzare un workflow personalizzato per specificare in modo esplicito quali risorse di rete esistenti utilizzare, incluse le subnet esistenti in cui creare i load balancer.

Per utilizzare un'altra larghezza di banda per il load balancer, filtrare la relativa conteggio, ad esempio larghezza di banda da 100 Mbps o larghezza di banda da 400 Mbps.

Crea un token di autorizzazione
  1. Nel menu di navigazione , selezionare il menu Profilo Icona menu Profilo e quindi selezionare Impostazioni utente o Profilo personale, a seconda dell'opzione visualizzata.
  2. Fare clic su Token di autenticazione.
  3. Fare clic su Genera token.
  4. Fornire una descrizione.
  5. Fare clic su Genera token.
  6. Copiare il token e salvarlo.
  7. Fare clic su Chiudi.
Nota

Assicurarsi di salvare il token subito dopo averlo creato. Non si dispone dell'accesso in seguito.
Raccogliere le informazioni necessarie
  1. Raccogliere le seguenti informazioni sulle credenziali dalla console di Oracle Cloud Infrastructure.
    • Nome tenancy: <tenancy-name>
      • Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo, quindi selezionare Tenancy: <your_tenancy_name>.
    • Spazio di nomi tenancy: <tenancy-namespace>
      • Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo, quindi selezionare Tenancy: <your_tenancy_name>.
      • Copiare il valore per Spazio di nomi dello storage degli oggetti.
      Nota

      Per alcuni account, il nome della tenancy e lo spazio di nomi sono diversi. Assicurarsi di utilizzare lo spazio di nomi in questa esercitazione.
    • OCID tenancy: <tenancy-ocid>
      • Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo e quindi selezionare Impostazioni utente o Profilo personale, a seconda dell'opzione visualizzata.
      • Copia OCID.
    • Nome utente: <user-name>
      • Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo e quindi selezionare Impostazioni utente o Profilo personale, a seconda dell'opzione visualizzata.
    • OCID utente: <user-ocid>
      • Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo e quindi selezionare Impostazioni utente o Profilo personale, a seconda dell'opzione visualizzata.
      • Copia OCID.
  2. Trova le informazioni sulla tua regione.
    • Area: <region-identifier>
      • Nella barra di navigazione superiore della console, trova la tua area. Esempio: US East (Ashburn).
      • Trovare l'identificativo area dalla tabella in Aree e domini di disponibilità.
      • Esempio: us-ashburn-1.
    • Chiave area: <region-key>
  3. Copiare il token di autenticazione dalla sezione Crea un token di autenticazione.
    • Token di autenticazione: <auth-token>

2. Imposta un cluster

Installare e configurare le opzioni di gestione per il cluster Kubernetes. Successivamente, distribuire l'applicazione in questo cluster.

Aggiungi criterio compartimento

Se il nome utente si trova nel gruppo Amministratori, saltare questa sezione. In caso contrario, chiedere all'amministratore di aggiungere il criterio seguente alla tenancy:

allow group <the-group-your-username-belongs> to manage compartments in tenancy

Questo privilegio consente di creare un compartimento per tutte le risorse dell'esercitazione.

Passi per aggiungere il criterio
  1. Nel menu di navigazione selezionare il menu Profilo Icona menu Profilo e quindi selezionare Impostazioni utente o Profilo personale, a seconda dell'opzione visualizzata.
  2. Nel riquadro sinistro, fare clic su Gruppi.
  3. In un blocco note, copiare il nome gruppo a cui appartiene il nome utente.
  4. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità, fare clic su Criteri.
  5. Fare clic su Crea criterio.
  6. Inserire le seguenti informazioni:
    • Nome: manage-compartments
    • Descrizione: Allow the group <the-group-your-username-belongs> to list, create, update, delete and recover compartments in the tenancy.
    • Compartimento: <your-tenancy>(root)
  7. Per Costruzione guidata criteri, fare clic su Mostra editor manuale.
  8. Incolla nel seguente criterio:
    allow group <the-group-your-username-belongs> to manage compartments in tenancy
  9. Fare clic su Crea.

Di riferimento

Il tipo di risorsa compartments in Combinazioni Verbi + Tipo di risorsa per IAM

Crea un compartimento

Creare un compartimento per le risorse create in questa esercitazione.

  1. Accedi alla console di Oracle Cloud Infrastructure.
  2. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità, fare clic su Compartimenti.
  3. Fare clic su Crea compartimento.
  4. Inserire le seguenti informazioni:
    • Nome: <your-compartment-name>
    • Descrizione: Compartment for <your-description>.
    • Compartimento padre: <your-tenancy>(root)
  5. Fare clic su Crea compartimento.

Riferimento: creare un compartimento

Aggiungi criterio risorsa

Se il nome utente si trova nel gruppo Amministratori, saltare questa sezione. In caso contrario, chiedere all'amministratore di aggiungere il criterio seguente alla tenancy:

allow group <the-group-your-username-belongs> to manage all-resources in compartment <your-compartment-name>

Con questo privilegio, puoi gestire tutte le risorse nel tuo compartimento, concedendo in pratica i diritti amministrativi in tale compartimento.

Passi per aggiungere il criterio
  1. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità, fare clic su Criteri.
  2. Selezionare il compartimento dalla lista Compartimento.
  3. Fare clic su Crea criterio.
  4. Inserire le seguenti informazioni:
    • Nome: manage-<your-compartment-name>-resources
    • Descrizione: Allow users to list, create, update, and delete resources in <your-compartment-name>.
    • Compartimento: <your-tenancy>(root)
  5. In Costruzione guidata criteri, selezionare le scelte riportate di seguito.
    • Casi d'uso dei criteri: Compartment Management
    • Modelli di criteri comuni: Let compartment admins manage the compartment
    • Gruppi: <the-group-your-username-belongs>
    • Posizione: <your-tenancy>(root)
  6. Fare clic su Crea.

Di riferimento

Criteri comuni

Crea un cluster con 'Creazione rapida'

Creare un cluster con impostazioni predefinite e nuove risorse di rete tramite il workflow 'Creazione rapida'.

  1. Accedi alla console di Oracle Cloud Infrastructure.
  2. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Container e artifact, fare clic su Cluster Kubernetes (OKE).
  3. Fare clic su Crea cluster.
  4. Selezionare Creazione rapida.
  5. Fare clic su Avvia workflow.

    Viene visualizzata la finestra di dialogo Creazione rapida cluster.

  6. Inserire le seguenti informazioni.
    • Nome: <your-cluster-name>
    • Compartimento: <your-compartment-name>
    • Versione Kubernetes: <take-default>
    • Endpoint API Kubernetes: endpoint pubblico

      Il cluster Kubernetes è ospitato in una subnet pubblica con un indirizzo IP pubblico assegnato automaticamente.

    • Nodi di lavoro Kubernetes: lavoratori privati

      I nodi di lavoro Kubernetes sono ospitati in una subnet privata.

    • Forma: VM.Standard.E3.Flex
    • Selezionare il numero di OCPU: 1
    • Quantità di memoria (GB): 16
    • Numero di nodi: 3
    • Larghezza di banda della rete: 1.0 (questo valore viene calcolato in base al conteggio di OCPU).
    • Numero massimo di VNIC totali: 2 (questo valore viene calcolato in base al conteggio di OCPU).
  7. Fare clic su Show Advanced Options.

    Mantenere le impostazioni predefinite.

    • Specificare una dimensione del volume di avvio personalizzata: deselezionare la casella di controllo.
    • Verifica immagine: deselezionare la casella di controllo.
    • Aggiungere una chiave SSH: nessuna chiave SSH
  8. Fare clic su Successivo.

    Vengono visualizzate tutte le scelte effettuate. Esaminali per assicurarti che tutto sia configurato correttamente.

  9. Fare clic su Crea cluster.

    Vengono visualizzati i servizi impostati per il cluster.

  10. Fare clic su Chiudi.
  11. Ottieni una tazza di caffè. La creazione del cluster richiede alcuni minuti.
Creazione di un cluster Kubernetes riuscita.
Configurare Cloud Shell per l'accesso al cluster

Dopo aver creato un cluster Kubernetes, impostare Cloud Shell per accedere al cluster.

  1. Accedi alla console di Oracle Cloud Infrastructure.
  2. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Container e artifact, fare clic su Cluster Kubernetes (OKE).
  3. Fare clic sul collegamento a <your-cluster>.

    Vengono visualizzate le informazioni sul cluster.

  4. Fare clic su Accedi al cluster.
  5. Fare clic su Accesso a Cloud Shell. Seguire i passi della finestra di dialogo. I seguenti passaggi sono forniti come riferimento.
  6. Fare clic su Avvia Cloud Shell. In alternativa, dal menu principale è possibile fare clic sull'icona Cloud Shell (cloud-shell-icon) e avviare una sessione.
  7. Controllare la versione dell'interfaccia CLI oci e verificare che Cloud Shell funzioni.
    oci -v
  8. Creare un file kubeconfig per l'impostazione. Utilizzare le informazioni della finestra di dialogo Accedi al cluster.
    oci ce cluster create-kubeconfig <use data from dialog>
    Viene visualizzato un messaggio che:
    New config written to the Kubeconfig file <your-home-directory>/.kube/config
    Nota

    Se il file config non è memorizzato nella posizione predefinita (~/.kube/config), è necessario esportare la variabile di ambiente KUBECONFIG in modo che punti alla posizione.
    export KUBECONFIG=$HOME/<new-location>/config
    Nota

    Quando si utilizzano più cluster, è necessario specificare un file di configurazione specifico nella riga di comando. Ad esempio:
    kubectl --kubeconfig=</path/to/config/file> <some-command>
  9. Eseguire il test della configurazione del cluster con il comando seguente.

    Elenca cluster:

    kubectl get service

L'impostazione dell'accesso al cluster consente di preparare l'applicazione per la distribuzione.

3. Crea l'applicazione Docker

Successivamente, imposta il framework Flask su Cloud Shell. Quindi, creare ed eseguire un'applicazione Python.

Creare un'applicazione locale

Crea la tua applicazione Flask.

  1. Installare Flask.
    pip3 install --user Flask
  2. Creare una directory per l'applicazione.
    mkdir python-hello-app
  3. Spostarsi nella directory python-hello-app.
    cd python-hello-app
  4. Creare un'applicazione "Ciao, mondo!"

    Creare il file:

    vi hello.py

    Nel file, immettere il testo seguente:

    from flask import Flask
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        return '<h1>Hello World from Flask!</h1>'
    
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=int("5000"), debug=True)
  5. Salvare il file.
Eseguire l'applicazione locale

Eseguire l'applicazione Flask.

  1. Eseguire il programma Python.
    export FLASK_APP=hello.py
    export FLASK_ENV=development
    python3 hello.py

    Viene prodotto l'output seguente:

    * Serving Flask app 'hello' (lazy loading)
    * Environment: development
    * Debug mode: on
    * Running on all addresses.
    WARNING: This is a development server. Do not use it in a production deployment.
    * Running on http://x.x.x.x:5000/ (Press CTRL+C to quit)
    * Restarting with stat
    * Debugger is active!
    * Debugger PIN: xxx-xxx-xxx                    
  2. Sposta l'app in background.
    • Premere Ctrl z.
    • Immettere il comando: bg
  3. Eseguire il test dell'applicazione utilizzando curl.
    Nel terminale Cloud Shell, immettere il codice seguente:
    curl -X GET http://localhost:5000

    output:

    <h1>Hello World from Flask!</h1>
  4. Arrestare l'applicazione in esecuzione.
    • Al termine dei test, ottenere l'ID processo per l'applicazione.
      ps -ef
    • Arrestare il processo.
      kill <your-pid>

Creazione di un'applicazione Python locale con la struttura Flask riuscita.

Riferimenti:

Per ulteriori informazioni su Flask, vedere Documentazione sulla maschera.

Crea un'immagine Docker

Successivamente, crea un'immagine Docker per l'applicazione Flask.

  1. Innanzitutto, verificare di trovarsi nella directory python-hello-app.
  2. Creare un file denominato Dockerfile:

    Creare il file:

    vi Dockerfile

    Nel file, inserire il testo seguente e salvare il file:

    FROM python:3.9-slim-buster
    ADD hello.py /
    COPY . /app
    WORKDIR /app
    RUN pip3 install Flask
    EXPOSE 5000
    CMD [ "python3", "./hello.py" ]
  3. Crea un'immagine Docker:
    docker build -t python-hello-app .

    Hai un messaggio di successo.

    [INFO] BUILD SUCCESS
    Successfully tagged python-hello-app:latest
  4. Eseguire l'immagine Docker:
    docker run --rm -p 5000:5000 python-hello-app:latest &
  5. Eseguire il test dell'applicazione utilizzando il comando curl:
    curl -X GET http://localhost:5000
    Se si ottiene <h1>Hello World from Flask!</h1>, l'immagine Docker è in esecuzione. Ora puoi inviare l'immagine a Container Registry.
  6. Arrestare l'applicazione in esecuzione.
    • Al termine dei test, ottenere l'ID processo per l'applicazione.
      ps -ef
    • Arrestare il processo.
      kill <your-pid>
Complimenti. Creazione di un'immagine Docker del flag Python riuscita.

4. Distribuisci immagine Docker

Con l'immagine Python creata, ora puoi distribuirla.

Creare un repository Docker
  1. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Container e artifact fare clic su Container di registro.
  2. Nella navigazione a sinistra, selezionare <your-compartment-name>.
  3. Fare clic su Crea repository.
  4. Creare un repository privato con il nome del repository scelto:
    <repo-name> = <image-path-name>/<image-name>

    Esempio: flask-apps/python-hello-app

    Ora è possibile eseguire il PUSH dell'immagine locale in Container Registry.
    Nota

    Prima di poter eseguire il PUSH di un'immagine Docker in un repository del registro, il repository deve esistere nel compartimento. Se il repository non esiste, il comando push Docker non funziona correttamente.
    Nota

    La barra nel nome di un repository non rappresenta una struttura di directory gerarchica. L'opzione <image-path-name> facoltativa consente di organizzare i repository.
Push dell'immagine locale

Con l'immagine Docker locale creata, eseguire il PUSH dell'immagine nel registro dei container.

Procedere come segue.

  1. Aprire una finestra di terminale.
  2. Accedi a Container Registry:
    docker login <region-key>.ocir.io

    Viene richiesto di fornire il nome di login e la password personali.

    • Nome utente: <tenancy-namespace>/<user-name>
    • Password: <auth-token>
  3. Elenca le tue immagini Docker locali:
    docker images

    Vengono visualizzate le immagini Docker nel sistema. Identificare l'immagine creata nell'ultima sezione: python-hello-app

  4. Contrassegnare l'immagine locale con l'URL per il registro più il nome del repository, in modo da poterla inviare a tale repository.
    docker tag <your-local-image> <repo-url>/<repo-name>
    • Sostituire <repo-url> con:
      <region-key>.ocir.io/<tenancy-namespace>/
    • Sostituire <repo-name> con:

      <image-folder-name>/<image-name> dalla sezione Crea un repository Docker.

    • Ecco un esempio dopo aver combinato entrambi:
      docker tag python-hello-app iad.ocir.io/my-namespace/flask-apps/python-hello-app

      In questo esempio, i componenti sono:

      • URL repository: iad.ocir.io/my-namespace/
      • Nome repository: flask-apps/python-hello-app
    Nota

    OCI Container Registry ora supporta la creazione di un repository del registro in qualsiasi compartimento anziché solo nel compartimento radice (tenancy). Per inviare l'immagine al repository creato, combinare l'URL del registro con il nome esatto del repository. OCI Container Registry corrisponde al nome repository univoco ed esegue il push dell'immagine.
  5. Controllare le immagini Docker per verificare se l'immagine è copiata.
    docker images
    • L'immagine contrassegnata o l'immagine copiata ha lo stesso ID immagine dell'immagine locale.
    • Il nome dell'immagine copiata è:
      <region-key>.ocir.io/<tenancy-namespace>/<image-folder-name>/<image-name>
  6. Eseguire il push dell'immagine in Container Registry.
    docker push <copied-image-name>:latest
    Ad esempio:
    docker push iad.ocir.io/my-namespace/flask-apps/python-hello-app:latest
  7. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Container e artifact fare clic su Container di registro.

Trovare l'immagine in Container Registry dopo il completamento del comando push.

Distribuisci immagine
Con la tua immagine in Container Registry, ora puoi distribuire l'immagine e l'applicazione.
  1. Creare un segreto di registro per l'applicazione. Questo segreto autentica l'immagine quando viene distribuita nel cluster.

    Per creare il segreto, inserire le informazioni in questo modello .

    kubectl create secret docker-registry ocirsecret --docker-server=<region-key>.ocir.io  --docker-username='<tenancy-namespace>/<user-name>' --docker-password='<auth-token>'  --docker-email='<email-address>'

    Dopo l'esecuzione del comando, viene visualizzato un messaggio simile al seguente: secret/ocirsecret created.

  2. Verificare che il segreto sia stato creato. Eseguire il comando seguente:
    kubectl get secret ocirsecret --output=yaml

    L'output include informazioni sul segreto in formato yaml.

  3. Determinare l'URL host per l'immagine del registro utilizzando il seguente modello:
    <region-code>.ocir.io/<tenancy-namespace>/<repo-name>/<image-name>:<tag>
    Ad esempio:
    iad.ocir.io/my-namespace/flask-apps/python-hello-app:latest
  4. Nel sistema, creare un file denominato app.yaml con il testo seguente:
    Sostituire i segnaposto seguenti:
    • <your-image-url>
    • <your-secret-name>
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: app
    spec:
      selector:
        matchLabels:
          app: app
      replicas: 3
      template:
        metadata:
          labels:
            app: app
        spec:
          containers:
          - name: app
            image: <your-image-url>
            imagePullPolicy: Always
            ports:
            - name: app
              containerPort: 5000
              protocol: TCP
          imagePullSecrets:
            - name: <your-secret-name>
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: app-lb
      labels:
        app: app
      annotations:
        service.beta.kubernetes.io/oci-load-balancer-shape: "flexible"
        service.beta.kubernetes.io/oci-load-balancer-shape-flex-min: "10"
        service.beta.kubernetes.io/oci-load-balancer-shape-flex-max: "100"
    spec:
      type: LoadBalancer
      ports:
      - port: 5000
      selector:
        app: app
  5. Distribuire l'applicazione con il comando seguente.
    kubectl create -f app.yaml
    output:
    deployment.apps/app created
    Nota

    Nel file app.yaml, il codice dopo i trattini aggiunge un load balancer flessibile.
Prova l'app
Dopo aver distribuito l'applicazione, il caricamento del load balancer potrebbe richiedere alcuni secondi.
  1. Controllare se il load balancer è attivo:
    kubectl get service

    Ripetere il comando finché al load balancer non viene assegnato un indirizzo IP.

    Nota

    Durante l'attesa della distribuzione del load balancer, è possibile controllare lo stato del cluster con i seguenti comandi:
    • Ottieni lo stato di ogni pod: kubectl get pods
    • Ottieni lo stato dell'app: kubectl get deployment
  2. Utilizzare l'indirizzo IP del load balancer per connettersi all'applicazione in un browser:
    http://<load-balancer-IP-address>:5000

    Il browser visualizza: <h1>Hello World from Flask!</h1>

  3. Annullare la distribuzione dell'applicazione dal cluster. (Facoltativo) Per rimuovere l'applicazione, eseguire il comando seguente:
    kubectl delete -f app.yaml
    output:
    deployment.apps/python-hello-app deleted
    service "python-hello-app-lb" deleted

    L'applicazione è stata rimossa dal cluster.

Pagina successiva

Hai creato un'applicazione Hello World Python, l'hai distribuita in un cluster Kubernetes e l'hai resa accessibile su Internet, utilizzando la struttura Flask.

Dai un'occhiata a questi siti per scoprire ulteriori informazioni sullo sviluppo con i prodotti Oracle: