Configura la CLI

In questo passo, configurerai oc per puntare al tuo cluster appena creato. La CLI della piattaforma container Red Hat OpenShift on IBM Cloud espone comandi per la gestione delle applicazioni, nonché strumenti di livello inferiore per interagire con ciascun componente del sistema. La CLI è disponibile utilizzando il comando oc.

1. Quando il cluster è pronto, fai clic su Console webOpenShift per aprirla.
2. Sulla console web, dal menu a discesa in alto a destra nella pagina, fai clic su Copy Login Command e poi sul link Display Token.
3. Copiare il testo che si trova in Log in with this token.
4. Una volta effettuato l'accesso con il comando oc login, eseguire il comando seguente per visualizzare tutti i namespace del cluster.

   oc get ns
   

Crea un progetto

Uno spazio dei nomi Kubernetes fornisce un meccanismo per delimitare l'ambito delle risorse in un cluster. In Red Hat OpenShift on IBM Cloud, un progetto è uno spazio dei nomi Kubernetes con annotazioni aggiuntive.

1. Definire una variabile di ambiente denominata MYPROJECT e impostare il nome dell'applicazione sostituendo <your-initials> con le proprie iniziali:

   export MYPROJECT=<your-initials>-openshiftapp
   

2. Crea un nuovo progetto.

   oc new-project $MYPROJECT
   

   Dopo aver creato un progetto utilizzando il precedente comando, si passa automaticamente a tale progetto e tutti i comandi che seguono vengono eseguiti nel contesto di tale progetto. Se è necessario commutare i progetti o tornare a tale progetto in un secondo momento, utilizzare il comando oc project $MYPROJECT.

Distribuisce un'applicazione

Con il comando oc new-app è possibile creare applicazioni dal codice sorgente in un repository Git locale o remoto.

1. Crea un'applicazione utilizzando la strategia di build docker per creare un'immagine del contenitore da un Dockerfile nel repository. Si sta impostando il nome dell'applicazione sul nome del progetto per semplicità.

   oc new-app https://github.com/IBM-Cloud/openshift-node-app --name=$MYPROJECT --strategy=docker --as-deployment-config
   

   Se un file Jenkins esiste nella directory root o nella directory di contesto specificata del repository di origine durante la creazione di una nuova applicazione, Red Hat OpenShift on IBM Cloud genera una strategia di build pipeline. Altrimenti, genera una strategia di build source. È sempre possibile sovrascrivere la strategia di build impostando l'indicatore --strategy.

2. Per controllare la creazione dell'immagine del contenitore del builder ed eseguire il push alla Red Hat OpenShift on IBM Cloud Container Registry (OCR) interna, eseguire il seguente comando.

   oc logs -f buildconfig/$MYPROJECT
   

   Il cluster è configurato con il sito interno Red Hat OpenShift on IBM Cloud Container Registry in modo che Red Hat OpenShift on IBM Cloud possa costruire, distribuire e gestire automaticamente il ciclo di vita dell'applicazione dall'interno del cluster.

3. Attendere che la compilazione abbia successo e che l'immagine venga inviata. È possibile controllare lo stato della distribuzione e del servizio eseguendo il comando riportato di seguito.

   oc status
   

Accedere all'applicazione tramite il dominio fornito da IBM

Per accedere all'applicazione, è necessario creare un percorso. Un instradamento annuncia il tuo servizio al mondo.

1. Creare una rotta eseguendo il comando seguente in un terminale.

   oc expose service/$MYPROJECT
   

2. È possibile accedere all'applicazione tramite un dominio fornito da IBM. Eseguire il comando seguente per ottenere l' URL.

   oc get route/$MYPROJECT
   

3. Copiate il valore dell'hostname sotto il valore HOST/PORT e incollate URL in un browser per vedere la vostra applicazione in azione su http://<hostname>. Assicuratevi di utilizzare http nell' URL.

4. Impostare una variabile di ambiente che punti al nome host.

   export HOST=<hostname>
   

Proteggi l'instradamento del dominio fornito da IBM predefinito

1. Per creare un instradamento HTTPS protetto crittografato con il certificato predefinito per Red Hat OpenShift on IBM Cloud, puoi utilizzare il comando create route.

   oc create route edge $MYPROJECT-https --service=$MYPROJECT --port=3000
   

2. Per l'URL HOST HTTPS, esegui oc get routes. Copiare e incollare URL con HTTPS (https://<HOST>) accanto alla rotta $MYPROJECT-https in un browser. Questa volta è possibile utilizzare https nell' URL.

Ridimensionamento manuale

1. Puoi ottenere il ridimensionamento manuale dei tuoi pod con il comando oc scale. Il comando imposta una nuova dimensione per una configurazione di distribuzione o un controller di replica

   oc scale dc/$MYPROJECT --replicas=2
   

2. Puoi visualizzare il provisioning di un nuovo pod eseguendo il comando oc get pods.
3. Rieseguire il passo Monitoraggio per vedere le metriche aggiornate.

Ridimensionamento automatico

Puoi utilizzare un HPA (horizontal pod autoscaler - autoscaler di pod orizzontale) per specificare come Red Hat OpenShift on IBM Cloud dovrebbe aumentare o diminuire automaticamente la dimensione di una configurazione di distribuzione (dc) o del controller della replica (rc), in base alle metriche raccolte dai pod che appartengono a tale dc o rc.

1. Prima di poter configurare il ridimensionamento automatico dei tuoi pod, devi prima configurare dei limiti di risorse sui pod in esecuzione nel cluster. I limiti ti consentono di scegliere l'utilizzo di memoria e CPU minimo e massimo di un pod. Puoi configurare i limiti e le richieste su un contenitore utilizzando il comando oc set resources.

   oc set resources dc/$MYPROJECT --limits=cpu=250m,memory=512Mi --requests=cpu=100m,memory=256Mi
   

   Per verificare, esegui oc describe dc/$MYPROJECT e cerca Limits e Requests.
2. Per creare un autoscaler, devi eseguire il comando oc autoscale con i limiti inferiore (min) e superiore (max) per il numero di pod che possono essere impostati dall'autoscaler e l'utilizzo di CPU media di destinazione (rappresentato da una percentuale di CPU richiesta) su tutti i pod. Per i test, impostiamo --cpu-percent al 5%.

   oc autoscale dc/$MYPROJECT \
    --min=1 \
    --max=5 \
    --cpu-percent=5
   

3. Rieseguire il passo Monitoraggio per generare il carico sull'applicazione.
4. Puoi vedere i nuovi pod di cui viene eseguito il provisioning eseguendo il comando oc get pods --watch o esaminando l'applicazione nella console web.
5. Rimuovi il scaler automatico:

   oc delete hpa/$MYPROJECT
   

Clona un'applicazione di esempio

In questa sezione, clonerai un repository GitHub che viene fornito con un file template e uno script shell per generare un file yaml dalle tue variabili di ambiente precedentemente create. Il file generato viene utilizzato per creare un'immagine del contenitore, eseguire il push dell'immagine al registro del contenitore privato e distribuire una nuova applicazione.

1. In un terminale, immetti il seguente comando per clonare il repository GitHub sulla tua macchina:

   git clone https://github.com/IBM-Cloud/openshift-node-app
   

2. Passare alla directory dell'applicazione:

   cd openshift-node-app
   

Aggiorna il file BuildConfig ed esegui il push dell'immagine del builder a Container Registry

In questo passo, esegui uno script per aggiornare le sezioni del file openshift.template.yaml e generare un nuovo file yaml che punta al tuo spazio dei nomi Container Registry.

1. Eseguire lo script bash riportato di seguito per aggiornare i segnaposto nel file openshift.template.yaml e generare il file openshift_private_registry.yaml.

   ./generate_yaml.sh use_private_registry
   

2. Eseguire il comando di esportazione dall'output per impostare la variabile di ambiente MYPROJECT esistente con il nuovo nome applicazione. Eseguire echo $MYPROJECT per visualizzare il nuovo nome applicazione.

3. Facoltativamente, controllare il file openshift_private_registry.yaml generato per vedere se tutti i segnaposto sono aggiornati con le rispettive variabili di ambiente. I seguenti sono 3 posti per fare un rapido controllo. È possibile passare alla sezione successiva.

4. Facoltativo Individuare l'oggetto ImageStream con l'attributo name impostato sul progetto ($MYPROJECT) e verificare se i segnaposto $MYREGISTRY,$MYNAMESPACE e $MYPROJECT nella definizione dockerImageRepository di spec sono aggiornati

   -
   apiVersion: image.openshift.io/v1
   kind: ImageStream
   metadata:
     annotations:
       openshift.io/generated-by: OpenShiftNewApp
     creationTimestamp: null
     labels:
       app: $MYPROJECT
       app.kubernetes.io/component: $MYPROJECT
       app.kubernetes.io/instance: $MYPROJECT
     name: $MYPROJECT
   spec:
     dockerImageRepository: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT
     lookupPolicy:
       local: false
   status:
       dockerImageRepository: ""
   

   Un flusso di immagini e le sue tag associate forniscono un'astrazione per fare riferimento alle immagini del contenitore all'interno di Red Hat OpenShift on IBM Cloud Container Platform

5. Facoltativo Controllare la sezione spec sotto BuildConfig per la serie di output da immettere DockerImage e i segnaposto in name aggiornati.

   spec:
     nodeSelector: null
     output:
       to:
         kind: DockerImage
         name: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT:latest
       pushSecret:
         name: push-secret
   

   Una build è il processo di trasformazione dei parametri di input in un oggetto risultante. Molto spesso, il processo viene utilizzato per trasformare i parametri di input o il codice sorgente in un'immagine eseguibile. Un oggetto BuildConfig è la definizione dell'intero processo di build.

6. Facoltativo Ricercare containers, controllare image e name

   containers:
   - image: $MYREGISTRY/$MYNAMESPACE/$MYPROJECT:latest
     name: $MYPROJECT
   

7. Se aggiornato, salva il file YAML.

Distribuisci l'applicazione utilizzando IBM Cloud Container Registry

In questa sezione, si distribuirà l'applicazione nel cluster utilizzando il file generato openshift_private_registry.yaml generato. Una volta distribuita, accederai all'applicazione creando un instradamento.

1. Creare una nuova applicazione OpenShift con un buildconfig(bc), deploymentconfig(dc), service(svc), imagestream(is) usando lo yaml aggiornato.

   oc apply -f openshift_private_registry.yaml
   

2. Per verificare la creazione dell'immagine del contenitore del costruttore e il suo invio a Container Registry, eseguire il comando seguente.

   oc logs -f bc/$PRIVREG
   

   Nei log, dovresti vedere il seguente messaggio se l'immagine del contenitore viene inviata al registro del contenitore privato.

   Pushing image us.icr.io/mods15/vmac-openshift-app-registry:latest ...
   Getting image source signatures
   Copying blob sha256:9d038e1c7afbe92c29313557c02110e8fb796818ebb78441c68929381103a94b
   Copying blob sha256:61c671f49591a059c9b6728a9f84c16f5b00126470112ee9c9f9e01dbbfcc3ea
   Copying blob sha256:e2787650308235c87eff7d2b88c3ab217e84b74a3fa9696103bd46bb99068c7a
   Copying blob sha256:dcef409117430ed9906a59ad0a3ea0752061fbf8a9e544f4edd77667a25d85ae
   Copying blob sha256:a1f889dd610c6510c7fc091a51c247463f3cc9a7c67bdc397c9632168808f7d2
   Copying blob sha256:bd278801acd18ada10f43b732113a6fffc163011862ea6cde729f8dc59e64222
   Copying blob sha256:2d6c03ed5d15be86cdef7d9c0c9fea40a3f6b89662bca59680d037074f52bb38
   Copying blob sha256:fa2ef7f80d6fc9543f6eb472846931ed1cec2b5f776d1b67bcb1b9942e1a947e
   Copying blob sha256:ff5a4e4d3690ccc931900b63714d326cc53a58e644f8d0a4f06bf8c62f11c5c7
   Copying config sha256:01aa1ebb7be74529867106100c4e699ca2ae87f8242460771527f772e6a3d174
   Writing manifest to image destination
   Storing signatures
   Successfully pushed us.icr.io/mods15/vmac-openshift-app-registry@sha256:6847b889397704b9fb8c3122c84b505c3dc5f99a0669fb69f534d3504eec385d
   Push successful
   

3. È possibile controllare lo stato dell'installazione e del servizio.

   oc status
   

4. Importare manualmente il flusso di immagini più recente per garantire che il deployment avvenga il più presto possibile.

   oc import-image $PRIVREG
   

   È anche possibile utilizzare il comando se la distribuzione sta impiegando più tempo, fare riferimento a questo link per ulteriori informazioni.

5. Esponi il servizio per creare un nuovo instradamento.

   oc expose service/$PRIVREG
   

6. È possibile accedere all'applicazione tramite il dominio IBM. Eseguire il comando seguente per ottenere l' URL.

   oc get route/$PRIVREG
   

7. Copiate il valore dell'hostname sotto il valore HOST/PORT e incollate URL in un browser per vedere la vostra applicazione in azione su http://<hostname>. Assicuratevi di utilizzare http nell' URL.

   Dovresti vedere la stessa applicazione esposta su una rotta differente e distribuita utilizzando l'immagine del contenitore memorizzata in un registro del contenitore privato.

Crea un token di distribuzione Git

In questa sezione, si creerà un token di distribuzione Git per consentire l'accesso in sola lettura al repository.

Per generare un token di distribuzione:

1. Nel pannello di navigazione della pagina Git repo, fare clic su Impostazioni > Repository.
2. Fai clic su Expand accanto a Deploy Tokens.
   1. Nel campo Nome, immettere foropenshift e quindi selezionare read_repository in Ambiti. Infine fai clic su Crea token di distribuzione.
   2. Salvare il nome utente e la password generati per riferimento futuro.
3. Nel pannello di navigazione, fare clic su Panoramica del progetto, quindi fare clic su Clone e copiare Clonare con HTTPS URL. Salva l'URL per riferimento futuro.
4. Definire le variabili d'ambiente per il nome utente, la password e l' URL privato del repo Git, da usare con il file YAML più avanti nell'esercitazione

   export GIT_TOKEN_USERNAME=<PRIVATE_GIT_DEPLOY_TOKEN_USERNAME>
   export GIT_TOKEN_PASSWORD=<PRIVATE_GIT_DEPLOY_TOKEN_PASSWORD>
   export REPO_URL=<PRIVATE_GIT_REPO_URL>
   

Distribuisci una nuova applicazione utilizzando il registro privato e il codice dal repository privato

1. Eseguire lo script bash riportato di seguito per aggiornare i segnaposto nel file openshift.template.yaml e generare il file openshift_private_repository.yaml.

   ./generate_yaml.sh use_private_repository
   

2. Eseguire il comando di esportazione dall'output per impostare la variabile di ambiente MYPROJECT esistente con il nuovo nome progetto.

3. Oltre ai segnaposto del registro del contenitore privato, lo script sostituirà anche la specifica REPO_URL in BuildConfig con le variabili di ambiente impostate nel passo precedente,

    source:
      git:
        uri: $REPO_URL
      type: Git
   

4. Creare una nuova applicazione openshift con un buildconfig(bc), deploymentconfig(dc), service(svc), imagestream(is) utilizzando lo yaml aggiornato

   oc apply -f openshift_private_repository.yaml
   

5. È possibile controllare i log del builder.

   oc logs -f bc/$PRIVREPO
   

6. È possibile controllare lo stato dell'installazione e del servizio utilizzando.

   oc status
   

7. Importare manualmente il flusso di immagini più recente per garantire che il deployment avvenga il più presto possibile.

   oc import-image $PRIVREPO
   

8. Esponi il servizio per creare un nuovo instradamento.

   oc expose service/$PRIVREPO
   

9. È possibile accedere all'applicazione tramite il dominio IBM. Eseguire il comando seguente per ottenere l' URL.

   oc get route/$PRIVREPO
   

10. Copiate il valore dell'hostname sotto il valore HOST/PORT e incollate URL in un browser per vedere la vostra applicazione in azione su http://<hostname>. Assicuratevi di utilizzare http nell' URL.

    Una nuova applicazione viene distribuita utilizzando il codice dal repository Git privato e l'immagine contenitore dallo spazio dei nomi del registro privato.

Aggiornare l'applicazione e distribuirla nuovamente

In questo passo, automatizzerai il processo di creazione e distribuzione. Ogni volta che aggiorni l'applicazione ed esegui il push delle modifiche al repository privato, viene eseguita una nuova build che genera una nuova versione dell'immagine del contenitore. Questa immagine viene quindi distribuita automaticamente.

1. Creerai un nuovo trigger Webhook GitLab. I trigger Webhook ti consentono di attivare una nuova build inviando una richiesta all'endpoint API Red Hat OpenShift on IBM Cloud Container Platform. Puoi definire questi trigger utilizzando GitHub, GitLab, Bitbucket o webhook generici.

   oc set triggers bc $PRIVREPO --from-gitlab
   

2. Per aggiungere un webhook sul repository GitLab, hai bisogno di un URL e di un segreto

   • Per l'URL GitLab del webhook:

     oc describe bc/$PRIVREPO | grep -A 1 "GitLab"
     

   • Per il segreto che deve essere passato nell'URL del webhook:

     oc get bc/$PRIVREPO -o yaml | grep -A 3 "\- gitlab"
     

   • Sostituire <secret> nel webhook GitLab URL con il valore segreto sotto gitlab nell'output del comando precedente.

3. Aprire il repo git privato in un browser utilizzando il link Git repo HTTPS, quindi fare clic su Impostazioni e su Webhook.

4. Incollare l'URL, selezionare Eventi push come trigger e fare clic su Aggiungi webhook. Dovrebbe essere visualizzato il messaggio Webhook was created.

5. Aggiorna l'ImagePolicy del flusso di immagini per eseguire una query su Container Registry a un intervallo pianificato per sincronizzare i metadati di tag e immagine. Questa operazione aggiornerà la definizione di tags

   oc tag $MYREGISTRY/$MYNAMESPACE/${PRIVREPO}:latest ${PRIVREPO}:latest --scheduled=true
   

6. Aprire il repository clonato in un IDE per aggiornare il tag h1 del file locale public/index.html e cambiarlo in Congratulations! <insert your name>.

7. Salvare e inviare il codice al repository.

    git add public/index.html
   

    git commit -m "Updated with my name"
   

    git push -u origin master
   

8. Puoi controllare l'avanzamento della creazione e della distribuzione con il comando oc status. Una volta completata la distribuzione, aggiorna l'indirizzo HOST dell'instradamento per visualizzare l'applicazione web aggiornata.

   A volte, la distribuzione può richiedere fino a 15 minuti per importare il flusso di immagini più recente. È possibile attendere o importare manualmente con il comando oc import-image $PRIVREPO. Per ulteriori informazioni, fare riferimento a questo link.

Con HTTP

1. Creare una rotta che esponga il servizio a un nome di host, sostituendo <HOSTNAME> con il proprio nome di host (ad esempio, www.example.com o openshiftapp.example.com ), in modo che i client esterni possano raggiungerlo per nome.

   oc expose svc/$PRIVREPO --hostname=<HOSTNAME> --name=$PRIVREPO-domain --port=3000
   

2. Accedete alla vostra domanda su http://<HOSTNAME>/

Con HTTPS

1. Per creare un percorso HTTPS protetto, è possibile utilizzare il proprio certificato e i file delle chiavi di una CA come Let's Encrypt oppure ordinarli tramite Secrets Manager. Passali con il comando create route

   oc create route edge $PRIVREPO-httpsca --service=$PRIVREPO --cert=example.pem --key=example.key --hostname=<www.HOSTNAME> --port=3000
   

   Qui, hai utilizzato la terminazione Edge. Per ulteriori informazioni su altri tipi di terminazione e altri instradamenti protetti come passthrough e ricrittografia, esegui il comando oc create route --help