Distribuisci un'applicazione di frontend

1. Per distribuire una nuova applicazione Code Engine, immetti il seguente comando; fornendo un nome servizio frontend e l'immagine del contenitore precostruito come parametro per l'indicatore --image.

   ibmcloud code-engine application create --name frontend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-frontend
   

   Dopo aver eseguito questo comando, si dovrebbe vedere un output con un URL alla propria applicazione. Dovrebbe essere simile a: https://frontend.305atabsd0w.us-south.codeengine.appdomain.cloud. Copiare o annotare l' URL dell'applicazione per il passaggio successivo. Con questi due soli dati (nome dell'applicazione e nome dell'immagine), Code Engine ha distribuito la vostra applicazione e gestirà per voi le complessità della sua configurazione e gestione.

   Il codice di origine applicazione utilizzato per creare le immagini del contenitore è disponibile in un repositoryGitHub come riferimento. Se desideri creare le immagini del contenitore dal codice sorgente ed eseguirne il push a un Container Registryprivato, segui le istruzioni qui.

2. Aprite l' URL dell'applicazione del passo precedente in un browser per vedere un risultato simile a questo:

   

   Eseguire il comando ibmcloud code-engine application get -n frontend per visualizzare i dettagli dell'applicazione. Dovrebbero essere visualizzati dettagli come l'ID, le informazioni sul progetto, l'età dell'applicazione, l' URL per accedere all'applicazione, un URL della console per accedere alla configurazione dell'applicazione, l'immagine, l'allocazione delle risorse e le varie revisioni, condizioni e tempi di esecuzione dell'applicazione. Dal momento che si dispone di una sola revisione, si dovrebbe vedere che il 100% del traffico sta andando alla revisione più recente. Puoi anche verificare il numero di istanze e il relativo stato.

3. Per la risoluzione dei problemi e per controllare i log della tua applicazione, esegui il seguente comando sostituendo <INSTANCE_NAME> con il nome di una delle istanze dal comando ibmcloud code-engine application get -n frontend.

   Se non vengono visualizzate istanze in esecuzione, assicurarsi di aprire di nuovo l' URL dell'applicazione dal passaggio 2.

   ibmcloud code-engine application logs --instance <INSTANCE_NAME>
   

   Se l'applicazione è in esecuzione, dovresti vedere backend URL: undefined e App in ascolto sulla porta 8080. Più avanti nell'esercitazione, collegherai questa applicazione di frontend alla nostra applicazione di backend

Complimenti!! Hai appena distribuito un'applicazione web a Code Engine con un semplice comando e senza dover conoscere le complessità di Kubernetes come pod, distribuzioni, servizi e ingress.

Ridimensiona l'applicazione

Quando hai creato l'applicazione con il comando application create, hai passato solo un'immagine da utilizzare e un nome per la tua applicazione. Anche se questa è la quantità minima di informazioni per distribuire un'applicazione, ci sono un numero di altre manopole su cui hai il controllo. Tra le altre cose, è possibile impostare il numero di richieste che possono essere elaborate simultaneamente per istanza, la quantità di CPU per l'istanza dell'applicazione, la quantità di memoria impostata per l'istanza dell'applicazione, le variabili di ambiente per l'applicazione, il numero massimo e minimo di istanze che possono essere utilizzate per questa applicazione e la porta su cui l'applicazione è in ascolto per le richieste.

La maggior parte di questi valori ha un valore predefinito impostato se non viene fornito alcun valore come opzione durante la creazione dell'applicazione. Poiché non abbiamo fornito un valore, Code Engine ha distribuito la nostra applicazione con una scala massima predefinita di 10, il che significa che ridimensionerà la nostra applicazione solo fino a 10 istanze. La scala minima predefinita è zero, in modo che quando la nostra applicazione non è più in uso, si ridimensionerà a zero.

1. Per verificare le funzionalità di ridimensionamento automatico di Code Engine, possiamo utilizzare un generatore di carico per eseguire delle richieste rispetto al nostro servizio. Il seguente script shell simula un carico di base di 3000 richieste.

   1. Aprire una finestra terminale locale (shell).

   2. Creare una variabile di shell per l' URL dell'applicazione frontend dal passo precedente.

      export APPURL=<frontend-application-url>
      

   3. Eseguire il seguente script per generare del carico. Puoi ripeterlo per creare più traffico.

      seq 1 3000 | xargs -n1 -P300  curl -s  $APPURL -o /dev/null
      

2. Nella tua sessione Cloud Shell dalle sezioni precedenti, esegui il seguente comando per visualizzare il conteggio dell'istanza (pod) che aumenta come parte del ridimensionamento automatico.

   ibmcloud code-engine application get -n frontend
   

   Per impostazione predefinita, il numero massimo di richieste che possono essere elaborate simultaneamente per istanza è 10 e questo valore può essere modificato utilizzando l'indicatore --concurrency or -cn con il comando application update.

3. Se non si desidera consentire la creazione di un massimo di 10 istanze, è possibile regolare la scala massima in modo che sia un numero inferiore. Mentre la tua applicazione senza server può facilmente scalare, puoi dipendere da un servizio downstream come un DB SQL che può gestire solo un numero limitato di connessioni o un'altra API con frequenza limitata. Provare a limitare il numero di istanze per questa applicazione di frontend.

   ibmcloud code-engine application update --name frontend --max-scale 5
   

4. Una volta arrestata la creazione del carico, attendere alcuni minuti per vedere le istanze terminare, eventualmente riducendo a zero le istanze.

5. Nella tua finestra locale con il comando load generator, esegui di nuovo lo script per creare richieste rispetto all'app. Nella sessione Cloud Shell, esegui il comando ibmcloud code-engine application get -n frontend per vedere il numero di istanze aumentare a 5.

   Output previsto:

   Name                                        Revision        Running  Status   Restarts  Age
   frontend-00002-deployment-77d5fbfb5d-7zpfl  frontend-00002  3/3      Running  0         70s
   frontend-00002-deployment-77d5fbfb5d-kv6rn  frontend-00002  3/3      Running  0         69s
   frontend-00002-deployment-77d5fbfb5d-mhlwn  frontend-00002  3/3      Running  0         68s
   frontend-00002-deployment-77d5fbfb5d-qkjmd  frontend-00002  3/3      Running  0         67s
   frontend-00002-deployment-77d5fbfb5d-zpr9n  frontend-00002  3/3      Running  0         85s
   

Distribuisci un'applicazione di back - end e verifica la connessione

1. Per distribuire una nuova applicazione di backend per memorizzare i file di testo in IBM Cloud Object Storage, esegui questo comando

   ibmcloud code-engine application create --name backend --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend --cluster-local
   

   L'indicatore --cluster-local indicherà a Code Engine di mantenere privato l'endpoint per questa applicazione, il che significa che sarà disponibile solo dall'interno del progetto. Questo viene spesso utilizzato per scopi di sicurezza. In questo caso, non esiste alcun motivo per esporre l'applicazione di back - end con un endpoint pubblico, poiché non vi si accederà dall'esterno del cluster.

2. Copiare e salvare l'endpoint interno URL ) dall'output per utilizzarlo nel comando successivo. Il risultato è simile a quanto mostrato di seguito:

   BACKEND_PRIVATE_URL=http://backend.xxxxxx
   

   È possibile eseguire il comando ibmcloud code-engine application get -n backend per verificare lo stato e i dettagli dell'applicazione di backend, compreso l'URL.

3. L'applicazione di frontend utilizza una variabile di ambiente (BACKEND_URL) per sapere dove è ospitata l'applicazione di backend. Ora devi aggiornare l'applicazione di frontend per impostare questo valore in modo che punti all'endpoint dell'applicazione di backend.

   ibmcloud code-engine application update --name frontend --env BACKEND_URL=$BACKEND_PRIVATE_URL
   

   L'indicatore --env può essere visualizzato tutte le volte che si desidera se è necessario impostare più di una variabile di ambiente. Questa opzione potrebbe essere stata utilizzata anche sul comando ibmcloud code-engine application create per l'applicazione di frontend se ne conoscevi il valore in quel momento. Per ulteriori informazioni, consultare l'argomento della documentazione Utilizzo delle variabili di ambiente.

4. Aggiornare con forza l' URL del frontend sul browser per verificare la connessione all'applicazione di backend. Si dovrebbe vedere una pagina con un'opzione per caricare un file di testo(.txt) e anche un messaggio di errore dall'applicazione di backend, poiché quest'ultima non è ancora connessa con i servizi IBM Cloud richiesti per memorizzare ed elaborare i file di testo. Facendo clic su Carica file di testo dovrebbe essere visualizzato anche un messaggio di errore simile.

Esegui il provisioning dei servizi Object Storage e Natural Language Understanding

1. Crea un'istanza di Object Storage

   1. Seleziona il piano Lite o il piano Standard se hai già un'istanza del servizio Object Storage nel tuo account.
   2. Imposta Nome servizio su your - initials - code - engine - cos.
   3. Seleziona il gruppo di risorse in cui hai creato il progetto Code Engine.
   4. Fai clic su Create.
   5. Acquisire il nome del servizio in una variabile shell:

      COS_INSTANCE_NAME=your-initials-code-engine-cos
      

2. In Crea bucket, fai clic su Crea bucket, quindi in Crea un bucket personalizzato seleziona Crea.

   Quando si creano bucket o si aggiungono oggetti, assicurarsi di evitare l'utilizzo di PII (Personally Identifiable Information). Nota: PII sono informazioni che possono identificare qualsiasi utente (persona fisica) per nome, posizione o qualsiasi altro mezzo.

   1. Immetti Unique bucket name come <your-initials>-bucket-code-engine.
   2. Seleziona un' ubicazione, in cui hai creato il progetto Code Engine.
   3. Selezionare la classe di memoria Smart Tier.
   4. Fai clic su Crea bucket.
   5. Acquisisci il nome bucket in una variabile shell:

      COS_BUCKETNAME=your-initials-bucket-code-engine
      

3. Nella pagina bucket.

   1. Fare clic sulla scheda Configurazione
   2. L'endpoint Direct conserverà i dati in IBM Cloud. Acquisire l'endpoint diretto in una variabile shell. Nella regione di Dallas, Stati Uniti-Sud, potrebbe essere così:

      COS_ENDPOINT=s3.direct.us-south.cloud-object-storage.appdomain.cloud
      

4. Crea un'istanza di Natural Language Understanding

   1. Seleziona un'ubicazione e seleziona un piano Lite.
   2. Imposta Nome servizio su code - engine - nlu e seleziona il gruppo di risorse in cui hai creato il progetto Code Engine.
   3. Leggere l'accordo di licenza e selezionare Ho letto e accetto i seguenti accordi di licenza.
   4. Fai clic su Create.
   5. Acquisire il nome del servizio in una variabile shell:

      NLU_INSTANCE_NAME=YourServiceName
      

Legare il servizio Object Storage all'applicazione di backend

Ora, dovrai passare le credenziali per l'istanza IBM Cloud Object Storage che hai creato nella tua applicazione di back - end. Lo farai associando il servizio Object Storage alla tua applicazione, che aggiunge automaticamente le credenziali per un servizio alle variabili di ambiente per la tua applicazione o il tuo lavoro.

1. Crea un bind per il servizio Object Storage con un prefisso COS per facilitarne l'uso nell'applicazione. Il comando bind crea una credenziale del servizio nell'istanza del servizio e da ciò inizializza le variabili di ambiente dell'applicazione con le credenziali. Ciascun bind del servizio può essere configurato per utilizzare un prefisso della variabile di ambiente personalizzata utilizzando l'indicatore --prefix.

   ibmcloud code-engine application bind --name backend --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS
   

2. Dovrai anche fornire all'applicazione il tuo nome bucket dove vuoi archiviare i file di testo e il tuo endpoint COS. Entrambi sono stati definiti in una fase precedente. L'endpoint per us - south per il Livello smart è s3.direct.us-south.cloud-object-storage.appdomain.cloud.

   Definisci una configmap per conservare il nome del bucket e l'endpoint poiché le informazioni non sono sensibili. ConfigMaps sono un oggetto Kubernetes, che ti consente di separare le risorse di configurazione dal contenuto dell'immagine per mantenere portabili le applicazioni inserite nel contenitore. È possibile creare questa configmap da un file o da una coppia chiave - per ora utilizzeremo una coppia chiave - valore con l'indicatore --from-literal. Verificare di aver acquisito queste informazioni in precedenza e creare la configmap:

   echo bucket $COS_BUCKETNAME endpoint $COS_ENDPOINT
   

   ibmcloud code-engine configmap create --name backend-configuration --from-literal=COS_BUCKETNAME=$COS_BUCKETNAME --from-literal=COS_ENDPOINT=$COS_ENDPOINT
   

3. Con la configmap definita, puoi ora aggiornare l'applicazione di backend chiedendo a Code Engine di impostare le variabili di ambiente nel runtime dell'applicazione in base ai valori nella configmap. Aggiornare l'applicazione backend con il seguente comando

   ibmcloud code-engine application update --name backend --env-from-configmap backend-configuration
   

   Per creare un segreto, è necessario utilizzare l'indicatore --env-from-secret. Sia i segreti che le mappe di configurazione sono "mappe"; quindi le variabili di ambiente impostate avranno un nome corrispondente alla "chiave" di ogni voce in tali mappe e i valori delle variabili di ambiente saranno il valore di quella "chiave".

4. Per verificare se l'applicazione di back - end è aggiornata con il bind e la configmap. È possibile eseguire il seguente comando e cercare le sezioni Service Bindings e Environment Variables nell'output

   ibmcloud code-engine application get --name backend
   

5. Vai alla IU di frontend e carica i file di testo per l'analisi del testo. Dovresti vedere i file caricati con la tag Not analyzed.

Crea un lavoro

I lavori, a differenza delle applicazioni che reagiscono alle richieste HTTP in arrivo, sono destinati a essere utilizzati per l'esecuzione di immagini di contenitori che contengono un eseguibile progettato per essere eseguito una sola volta e poi uscire. Quando si crea un job, è possibile specificare le informazioni di configurazione del carico di lavoro utilizzate ogni volta che viene eseguito il lavoro. È possibile creare un lavoro dalla console o con la CLI.

Questo lavoro leggerà i file di testo da IBM Cloud Object Storagee li analizzerà quindi utilizzando il servizio Natural Language Understanding. Dovrà avere accesso alle credenziali del servizio per entrambi i servizi.

1. Eseguire il seguente comando per creare un lavoro,

   ibmcloud code-engine job create --name backend-job --image icr.io/solution-tutorials/tutorial-text-analysis-code-engine-backend-job --env-from-configmap backend-configuration
   

   Puoi configurare la versione del servizio Natural Language Understanding utilizzando l'indicatore --env. Per la creazione di versioni, controllare questo link

Esegui il bind dei servizi IBM Cloud al processo

1. Creiamo un binding per il servizio Object Storage con un prefisso COS_JOB da utilizzare con i job per leggere i file caricati e per memorizzare i risultati,

   ibmcloud code-engine job bind --name backend-job --service-instance $COS_INSTANCE_NAME --role Writer --prefix COS_JOB
   

2. Allo stesso modo, eseguiamo il bind del servizio Natural Language Understanding con un prefisso NLU_JOB per analizzare il file di testo caricato,

   ibmcloud code-engine job bind --name backend-job --service-instance $NLU_INSTANCE_NAME --role Writer --prefix NLU_JOB
   

3. Per verificare se il lavoro è aggiornato con il bind e la configmap. È possibile eseguire il seguente comando e cercare le sezioni Service Bindings e Environment Variables nell'output

   ibmcloud code-engine job get --name backend-job
   

Eseguire il lavoro

1. Per eseguire un job con la configurazione creata in precedenza, utilizzare il comando jobrun submit,

   ibmcloud code-engine jobrun submit --name backend-jobrun --job backend-job
   

   Quando si esegue un lavoro, è possibile sovrascrivere molte delle variabili impostate nella configurazione del lavoro. Per controllare le variabili, eseguire ibmcloud code-engine jobrun submit --help.

2. Per verificare lo stato di jobrun, eseguire il seguente comando

   ibmcloud code-engine jobrun get --name backend-jobrun
   

3. I log possono essere visualizzati:

   ibmcloud code-engine jobrun logs --follow --name backend
   

4. Nell'interfaccia utente di frontend, fai clic sul pulsante refresh (accanto a Upload text file) per vedere le parole chiave e JSON per ognuno dei file di testo caricati. Il tag su ciascun file deve ora essere modificato in Analyzed.

5. Caricare nuovi file o eliminare singoli file facendo clic sull'icona elimina, inoltrare nuovamente jobrun con il comando riportato di seguito e premere il pulsante aggiorna per visualizzare i risultati.

   ibmcloud code-engine jobrun resubmit --jobrun backend-jobrun
   

Automatizza l'esecuzione del job

Invece di eseguire il lavoro manualmente, puoi automatizzare l'esecuzione del lavoro creando una sottoscrizione IBM Cloud Object Storage che ascolta le modifiche a un bucket Object Storage. Quando crei una sottoscrizione a un bucket, il tuo lavoro riceve un evento separato per ogni modifica riuscita a tale bucket.

1. Prima di poter creare una sottoscrizione Object Storage, devi assegnare il ruolo Notifications Manager a Code Engine. Come Gestore notifiche, Code Engine può visualizzare, modificare ed eliminare le notifiche per un bucket Object Storage. Segui le istruzioni qui per assegnare il ruolo Gestore notifiche al tuo progetto Code Engine.
2. Esegui il seguente comando per connettere il tuo backend-job al produttore dell'evento IBM Cloud Object Storage. Controllare e aggiornare bucket name prima di eseguire il comando

   ibmcloud code-engine subscription cos create --name backend-job-cos-event --destination-type job --destination backend-job --bucket $COS_BUCKETNAME --prefix files --event-type write
   

3. Ora, carica nuovi file e premi il pulsante di aggiornamento per visualizzare i risultati. In futuro, non è necessario inoltrare nuovamente l'esecuzione lavoro, poiché è gestita dalla sottoscrizione.