🥇Kaasaegsed rakendused OpenShiftis, osa 3: OpenShift arendusena ja OpenShift Pipelines'i töönädalad

Tere kõigile sellele blogisse! Teiega on kolmas postitus seeriast, kus me näitame, kuidas juurutada kaasaegseid veebirakendusi Red Hat OpenShiftis.

Kahes eelnevas postituses rääkisime, kuidas juurutada kaasaegseid veebirakendusi vaid mõne sammuga ja kuidas kasutada uut S2I pilti koos valmidus HTTP-serveriga, nagu NGINX, seotud kogumiste (chained builds) abil produktsiooni juurutamiseks.

Täna näitame, kuidas käivitada OpenShiftis arendusserver oma rakenduse jaoks ja sünkroonida see kohaliku failisüsteemiga, samuti arutame, mis on OpenShift Pipelines ja kuidas seda saab kasutada alternatiivina seotud kogumistele.

OpenShift arenduskeskkonnana

Arendustöövoog (development workflow)

Nagu juba mainitud esimeses postituses, tüüpiline arendusprotsess kaasaegsete veebirakenduste jaoks on lihtsalt mingi „arendusserver“, mis jälgib muudatusi kohalikes failides. Kui need toimuvad, käivitatakse rakenduse kogumine ja seejärel uuendatakse seda brauseris.

Enamikus kaasaegsetes raamistikudes on selline „arendusserver“ integreeritud vastavatesse käsurea tööriistadesse.

Kohalik näide

Alustame vaatamist, kuidas see töötab kohaliku rakenduste käivitamise korral. Näiteks võtame rakenduse React eelmistest artiklitest, kuigi praktiliselt samad töövoo kontseptsioonid kehtivad ka kõigi teiste kaasaegsete raamistikude puhul.
Nii et, et käivitada „arendusserver“ meie Reacti näites, sisestame järgmise käsu:

$ npm run start

Siis näeme terminali aknas umbes järgmist:

Ja meie rakendus avaneb brauseris vaikimisi:

Nüüd, kui me teeme muudatusi failis, peaks rakendus brauseris uuendama.

Olgu, arendamine kohaliku režiimis on selge, aga kuidas saavutada sama OpenShiftis?

Arendusserver OpenShiftis

Kui mäletate, siis tõin välja, et satelliidid ja praht, mis asuvad alla 600 km, kukuvad orbitaalilt paariaastaga — atmosfääri takistuse tõttu, vähendades oluliselt Kessleri sündroomi võimalusi. SpaceX'i tegevus prahi osas tundub, nagu nad ei mõtleks üldse kosmosereostusele. Vaadates Starlinki elluviimise detaile, on mul raske ette kujutada paremat moodust prahi hulga vähendamiseks orbiidil., käsitlesime nii nimetatud käivitamisfaasi (run phase) S2I pildis ja nägime, et meie veebirakendust teenindab vaikeselt moodul serve.

Kuid kui lähemalt vaadata käivitusskripti selles näites, siis on seal keskkonnamuutuja $NPM_RUN, mis võimaldab käivitada ka oma käsu.

Näiteks võime kasutada moodulit nodeshift, et käivitada meie rakendus:

$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app

Märkus: eespool toodud näide on lühendatud, et illustreerida üldist ideed.

Siin lisasime meie juurutamisele keskkonnamuutuja NPM_RUN, mis ütleb täitmisetapile, et ta peab käivitama käsu yarn start, mis käivitab Reacti arendusserveri meie OpenShifti pod'is.

Kui vaadata töötava pod'i logi, siis seal on umbkaudu järgmine:

Muidugi, see kõik ei tähenda midagi, kuni me suudame sünkroonida kohalikku koodi koodiga, mis samuti muutuste osas kontrollitakse, kuid elab kaugserveris.

Kauakoodide ja kohalike koodide sünkroniseerimine

Õnneks aitab nodeshift sünkroniseerimist hõlpsalt ning muutuste jälgimiseks võib kasutada käsku watch.

Nii et pärast seda, kui oleme käivitanud käsu arendusserveri käivitamiseks meie rakenduse jaoks, saame julgesti kasutada sellist käsku:

$ npx nodeshift watch

Tulemuseks on ühendamine käivitatud pod'iga, mille me varem lõime, aktiveeritakse meie kohalike failide sünkroniseerimine kaugklastriga ja failid meie kohalikus süsteemis hakkavad muutuste osas jälgima.

Seega, kui nüüd uuendada faili src/App.js, reageerib süsteem nendele muutustele, kopeerib need kaugklastrisse ja käivitab arendusserveri, mis seejärel värskendab meie rakendust brauseris.

Täielikkuse huvides näitame, millised need käsud kokku näevad:

$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000

$ npx nodeshift watch --strictSSL=false

Käsk watch on abstraktsioon käsust oc rsync, lisainfot selle toimimise kohta saab leida. siin.

See oli näide Reactist, kuid täpselt sama meetodit saab kasutada ka teiste raamistikudega, lihtsalt seadke keskkonnamuutuja NPM_RUN õigesti.

OpenShift Pipelines'i torud

Edasi räägime sellisest tööriistast kui OpenShift Pipelines ja sellest, kuidas seda saab kasutada alternatiividena seotud kogumitele chained build.

Mis on OpenShift Pipelines

OpenShift Pipelines on pilvepõhine CI/CD-süsteem, mis on mõeldud konveierite korraldamiseks Tektoni abil. Tekton on paindlik Kubernetes'i kohaletoimetamise ja integreerimise raamistik, millel on avatud lähtekood, mis võimaldab automatiseerida juurutamist erinevates platvormides (Kubernetes, serverless, virtuaalmasinad jne) madalama taseme abstrakteerimise kaudu.

Selle artikli mõistmiseks on vajalikud teatud teadmised Pipelines'ist, seega soovitame tungivalt alustada ametlikust õpikust.

Tööruumi seadistamine

Et mängida selle artikli näidistega, tuleb esmalt ette valmistada tööruum:

Installida ja seadistada OpenShift 4 klastri. Meie näidetes kasutatakse selleks CodeReady Containers (CRD), mille installimise juhised leiate siin.
Kui klaster on valmis, tuleb sellele installida Pipeline Operator. Ärge muretsege, see on lihtne, installimise juhised siin.
Laadi alla Tekton CLI (tkn) siin.
Käivitada käsurea tööriist create-react-app, et luua rakendus, mida hiljem juurutatakse (see on lihtne rakendus React).
(Valikuline) Kloonige hoidla, et kohapeal käitada rakenduse näidet käsuga npm install ja seejärel npm start.

Rakenduse hoidlas on samuti kaust k8s, kus asuvad Kubernetes'/OpenShift'i YAML-failid, mida kasutatakse rakenduse juurutamiseks. Seal on ülesanded, ClusterTasks, ressursid ja Pipelines, mille me selles hoidlad.

Alustame

Esmalt tuleb meie näite jaoks luua uus projekt OpenShift klastris. Nimetame selle projekti webapp-pipeline ja loome selle järgmise käsuga:

$ oc new-project webapp-pipeline

Edasi toob see projekti nimi koodis esile, seega kui otsustate nimetada selle kuidagi teisiti, ärge unustage vastavalt muuta näidiskoodi. Alates sellest kohast liikume mitte ülevalt alla, vaid alt üles: see tähendab, et esmalt loome kõik konveieri komponendid ja alles siis selle enda.

Nii et, kõigepealt…

Ülesanded

Loome kaks ülesannet (tasks), mis aitavad hiljem meie rakenduse juurutamist meie torustiku (pipeline) raames. Esimene ülesanne – apply_manifests_task – vastutab nende Kubernetes-resursside (service, deployment ja route) rakendamise eest, mis asuvad meie rakenduse k8s kaustas. Teine ülesanne – update_deployment_task – vastutab juba juurutatud pildi uuendamise eest, kasutades meie torustiku genereeritud pilti.

Ärge muretsege, kui see praegu veel selge pole. Tegelikult on need ülesanded midagi nagu utiliidid ja me käsitleme neid lähemalt natuke hiljem. Seniks loome need lihtsalt:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml

Seejärel kontrollime tkn CLI käsuga, et ülesanded on loodud:

$ tkn task ls

NAME                AGE
apply-manifests     1 minute ago
update-deployment   1 minute ago

Märkus: need on teie kohaliku projekti ülesanded.

Klastrilised ülesanded (Cluster tasks)

Klastrilised ülesanded on põhimõtteliselt sama, mis tavalised ülesanded. See tähendab, et need on taaskasutatavad sammude kogumid, mida kombineeritakse erinevatel viisidel konkreetse ülesande käivitamisel. Erinevus on see, et klastriline ülesanne on kergesti kättesaadav kogu klastris. Klastriliste ülesannete nime nägemiseks, mis luuakse automaatselt, kui lisatakse Pipeline Operator, kasutame taas tkn CLI käsku:

$ tkn clustertask ls

NAME                       AGE
buildah                    1 day ago
buildah-v0-10-0            1 day ago
jib-maven                  1 day ago
kn                         1 day ago
maven                      1 day ago
openshift-client           1 day ago
openshift-client-v0-10-0   1 day ago
s2i                        1 day ago
s2i-go                     1 day ago
s2i-go-v0-10-0             1 day ago
s2i-java-11                1 day ago
s2i-java-11-v0-10-0        1 day ago
s2i-java-8                 1 day ago
s2i-java-8-v0-10-0         1 day ago
s2i-nodejs                 1 day ago
s2i-nodejs-v0-10-0         1 day ago
s2i-perl                   1 day ago
s2i-perl-v0-10-0           1 day ago
s2i-php                    1 day ago
s2i-php-v0-10-0            1 day ago
s2i-python-3               1 day ago
s2i-python-3-v0-10-0       1 day ago
s2i-ruby                   1 day ago
s2i-ruby-v0-10-0           1 day ago
s2i-v0-10-0                1 day ago

Nüüd loome kaks klastrilist ülesannet. Esimene loob S2I pildi ja saadab selle OpenShift'i siseregisterisse; teine – ehitab meie pilti NGINX-i põhjal, kasutades juba koostatud rakendust sisu kujul.

Loome ja saadame pildi

Loomis esimest ülesannet, kordame seda, mida oleme juba teinud eelnevas artiklis seotud kogumite kohta. Kordame, et kasutasime S2I (ubi8-s2i-web-app) pilti, et 'koostada' oma rakendus, ja lõpuks saime pildi, mis salvestati OpenShift'i siseregistrisse. Nüüd kasutame seda S2I-pilti veebirakendusest, et luua oma rakenduse DockerFile ning siis rakendame Buildah'it, et teostada tegelik koostamine ja edastada saadud pilt OpenShift'i siseregistrisse, kuna see on täpselt see, mida OpenShift teeb, kui deployd oma rakendusi NodeShift'i abil.

Küsite, kust me kõik selle teadsime? официальной версии official Node.js, me kopeerisime selle ja kohandasime enda vajadustele.

Nüüd loome klastrite ülesande s2i-web-app:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml

Me ei hakka seda detailselt arutama, vaid peatume ainult OUTPUT_DIR parameetril:

params:
      - name: OUTPUT_DIR
        description: Koostamise väljundi katalooge asukoht
        default: build

Mugluse põhiselt on see parameeter equals build, just sinna paneb React koos toestatud sisu. Teistes raamistikes kasutatakse teisi teid, näiteks Ember'is on see dist. Meie esimeselt klastrite ülesande väljund representatsioon kajastab pilti, mis sisaldab koostatud HTML, JavaScript ja CSS.

Koostame pildi NGINX'i põhjal

See, mis meie teise klastrite ülesande osas, peab see koguma meile pildi NGINX'i põhjal, kasutades juba koostatud rakenduse sisu. Sisuliselt on see see osa eelmisest jaos, kus me käsitlesime seotud kogumite (chained builds) teemat.

Selleks loome - täpselt nagu ülalpool - klastrite ülesande webapp-build-runtime:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml

Kui vaadata nende klastrite ülesannete koodi, on näha, et seal ei ole täpsustatud Git'i repositooriumit, millega me töötame, ega ka pilti, mida me loome. Me lihtsalt määrame, mida me Git'i edastame või mingisugust pilti, kuhu lõpptoode pilt tuleb edastada. Just selle tõttu saab neid klastrite ülesandeid taaskasutada ka teiste rakenduste korral.

Ja siin liigume elegantset järgmise punkti juurde...

Resursid

Nii et, kuna nagu me just rääkisime, peavad klastrite ülesanded olema maksimaalselt üldistavad, peame looma ressursid, mis kasutavad sisendit (Git repository) ja väljundit (lõplikud pildid). Esimene ressurs, mida vajame, on Git, kus meie rakendus asub, näiteks midagi sellist:

# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: web-application-repo
spec:
  type: git
  params:
    - name: url
      value: https://github.com/nodeshift-starters/react-pipeline-example
    - name: revision
      value: master

Siin on PipelineResource tüüpi git. Klahv url section params määrab konkreetse repostaari ja seab master haru (see on valikuline, kuid kirjutame selle täiuslikkuse nimel).

Nüüd peame looma ressursi pildi jaoks, kuhu salvestatakse s2i-web-app ülesande tulemused, see tehakse nii:

# This resource is the result of running "npm run build",  the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: built-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest

Siin on PipelineResource tüüpi image, ja parameetri url väärtus viitab sisemisele OpenShift Image Registry'le, täpsemalt sellele, mis asub nimel webapp-pipeline. Ärge unustage muuta seda parameetrit, kui kasutate teistsugust nimeala.

Ja lõpuks, viimane ressurs, mida vajame, on samuti pildi tüüpi ning see on lõplik pilt NGINX, mida kasutatakse hiljem juurutamisel:

# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
  name: runtime-web-application-image
spec:
  type: image
  params:
    - name: url
      value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest

Ja jälle, pöörake tähelepanu, et see ressurs salvestab pildi OpenShift'i sisemisse registrisse nimel webapp-pipeline.

Kuna kõik need ressursid luua, kasutame käsku create:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml

Veenduda, et ressursid on loodud, saab nii:

$ tkn resource ls

Torni konveier

Nüüd, kui meil on kõik vajalikud koostisosad, kogume neist konveieri, luues selle järgmise käsuga:

$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml

Kuid enne, kui käivitame selle käsu, vaatame üle need koostisosad. Esimene on nimi:

apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
  name: build-and-deploy-react

Seejärel näeme section spec's ressursse, mille me varem lõime:

spec:
  resources:
    - name: web-application-repo
      type: git
    - name: built-web-application-image
      type: image
    - name: runtime-web-application-image
      type: image

Seejärel loome ülesanded, mida meie konveier peab täitma. Esmalt peab ta täitma juba loodud ülesande s2i-web-app:

tasks:
    - name: build-web-application
      taskRef:
        name: s2i-web-app
        kind: ClusterTask

See ülesanne võtab sisendi (gir-ressurss) ja väljundi (ressurs built-web-application-image) parameetrid. Me edastame talle samuti eriparameetri, et ta ei verifitseeriks TLS-i, kuna kasutame isesallekooditud sertifikaate:

ressursid:
        sisendid:
          - nimi: allikas
            ressurs: veebirakenduse-repo
        väljundid:
          - nimi: pilt
            ressurs: ehitatud-veebirakenduse-pilt
      parameetrid:
        - nimi: TLSVERIFY
          väärtus: "false"

Järgmine ülesanne on peaaegu sama, kuid siin kutsume juba loodud klastrite ülesannet webapp-build-runtime:

nimi: ehita-runtime-pilt
    ülesanneViide:
      nimi: webapp-build-runtime
      tüüp: ClusterTask

Nagu eelmise ülesande puhul, edastame ressursi, kuid nüüd on see ehitatud-veebirakenduse-pilt (meie eelmise ülesande väljund). Ja väljundina määrame taas pildi. Kuna see ülesanne peab toimuma pärast eelmist, lisame välja runAfter:

ressursid:
        sisendid:
          - nimi: pilt
            ressurs: ehitatud-veebirakenduse-pilt
        väljundid:
          - nimi: pilt
            ressurs: runtime-veebirakenduse-pilt
        parameetrid:
        - nimi: TLSVERIFY
          väärtus: "false"
      runAfter:
        - ehita-veebirakenduse

Järgmised kaks ülesannet vastutavad YAMLi-failide rakendamise eest, mis puudutavad teenust, marsruuti ja juurutamist, mis elavad meie veebirakenduse katalogis k8s, ning nende juurutamine uute piltide loomisel. Need kaks klastrite ülesannet määrasime juba artikli alguses.

Konteineri käivitamine

Nii et kõik meie konveieri osad on loodud ja käivitame selle järgmise käsuga:

$ tkn pipeline start build-and-deploy-react

Selles etapis kasutatakse käsurea liidest interaktiivses režiimis ning tuleb valida vastavad ressursid iga tema päringu vastusena: allika git jaoks valime veebirakenduse-repo, seejärel esimese pildi jaoks – ehitatud-veebirakenduse-pilt, ja lõpuks teise pildi jaoks – runtime-veebirakenduse-pilt:

? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr

Nüüd kontrollime konveieri olekut järgmise käsuga:

$ tkn pipeline logs -f

Pärast konveieri käivitamist ja rakenduse juurutamist küsime avaldatud marsruuti järgmise käsuga:

$ oc get route react-pipeline-example --template='http://{{.spec.host}}'

Visualiseerimise paremuse nimel võime vaadata meie konveienti arendaja režiimis veebikonsolis jaotises Torud, nagu on näidatud joonisel 1.

Joonis 1. Käivitatud konveieride ülevaade.

Klõpsamine käivitatud konveieril kuvab täiendavaid üksikasju, nagu on näidatud joonisel 2.

Joonis 2. Täiendavad üksikasjad konveieri kohta.

Pärast täiendavate üksikasjade vaatamist võime vaadata käivitatud rakendusi vaates Topoloogia, nagu on näidatud joonisel 3.

Joonis 3. Käivitatud pod.

Klõpsamine ikooni paremas ülanurgas avab meie rakenduse, nagu on näidatud joonisel 4.

Joonis 4. Käivitatud Reacti rakendus.

Kokkuvõte

Nii et, me näitasime, kuidas käivitada OpenShiftis arendusserver oma rakendusele ja sünkroonida see kohaliku failisüsteemiga. Samuti rääkisime, kuidas simuleerida chained-build mallide abil OpenShift Pipelines. Kõik näidiskoodid, mis selles artiklis on, on kergesti saadaval siin.