🥇Programu za kisasa kwenye OpenShift, sehemu ya 3: OpenShift kama mazingira ya ukuzaji na Mabomba ya OpenShift

Salamu kwa kila mtu kwenye blogi hii! Hili ni chapisho la tatu katika mfululizo ambapo tunaonyesha jinsi ya kupeleka programu za kisasa za wavuti kwenye Red Hat OpenShift.

Katika machapisho mawili yaliyotangulia, tulionyesha jinsi ya kupeleka programu za kisasa za wavuti kwa hatua chache tu na jinsi ya kutumia picha mpya ya S2I pamoja na picha ya seva ya HTTP iliyo nje ya rafu, kama vile NGINX, kwa kutumia miundo iliyofungwa kupanga upelekaji wa uzalishaji. .

Leo tutaonyesha jinsi ya kuendesha seva ya ukuzaji kwa programu yako kwenye jukwaa la OpenShift na kuisawazisha na mfumo wa faili wa ndani, na pia tutazungumza juu ya Mabomba ya OpenShift ni nini na jinsi yanavyoweza kutumika kama mbadala kwa makusanyiko yaliyounganishwa.

OpenShift kama mazingira ya maendeleo

Mtiririko wa kazi wa maendeleo

Kama ilivyoelezwa tayari katika chapisho la kwanza, mchakato wa kawaida wa ukuzaji wa programu za kisasa za wavuti ni aina fulani ya "seva ya ukuzaji" ambayo hufuatilia mabadiliko kwenye faili za karibu. Zinapotokea, uundaji wa programu huanzishwa na kisha inasasishwa kwa kivinjari.

Katika mifumo mingi ya kisasa, "seva ya maendeleo" kama hiyo imejengwa kwenye zana zinazolingana za mstari wa amri.

Mfano wa ndani

Kwanza, hebu tuone jinsi hii inavyofanya kazi wakati wa kuendesha programu ndani ya nchi. Hebu tuchukue maombi kama mfano Tenda kutoka kwa vifungu vilivyotangulia, ingawa karibu dhana sawa za mtiririko wa kazi hutumika katika mifumo mingine yote ya kisasa.
Kwa hivyo, kuanza "seva ya dev" katika mfano wetu wa React, tutaingiza amri ifuatayo:

$ npm run start

Kisha kwenye dirisha la terminal tutaona kitu kama hiki:

Na programu yetu itafungua katika kivinjari chaguo-msingi:

Sasa, ikiwa tutafanya mabadiliko kwenye faili, programu inapaswa kusasishwa kwenye kivinjari.

Sawa, kila kitu ni wazi na maendeleo katika hali ya ndani, lakini jinsi ya kufikia sawa kwenye OpenShift?

Seva ya ukuzaji kwenye OpenShift

Ikiwa unakumbuka, ndani chapisho lililopita, tuliangalia kinachojulikana kama awamu ya kukimbia ya picha ya S2I na tukaona kwamba kwa chaguo-msingi, moduli ya huduma inawajibika kuhudumia programu yetu ya wavuti.

Walakini, ikiwa utaangalia kwa karibu endesha hati kutoka kwa mfano huo, ina $NPM_RUN mazingira tofauti, ambayo hukuruhusu kutekeleza amri yako.

Kwa mfano, tunaweza kutumia moduli ya nodeshift kupeleka programu yetu:

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

Kumbuka: Mfano hapo juu umefupishwa ili kuonyesha wazo la jumla.

Hapa tumeongeza mabadiliko ya mazingira ya NPM_RUN kwenye utumiaji wetu, ambayo huambia wakati wa kukimbia kutekeleza amri ya kuanza kwa uzi, ambayo huanzisha seva ya ukuzaji ya React ndani ya ganda letu la OpenShift.

Ukiangalia logi ya pod inayoendesha, itaonekana kitu kama hiki:

Kwa kweli, haya yote hayatakuwa chochote hadi tuweze kusawazisha nambari ya ndani na nambari, ambayo pia inafuatiliwa kwa mabadiliko, lakini inaishi kwenye seva ya mbali.

Inasawazisha msimbo wa mbali na wa ndani

Kwa bahati nzuri, nodeshift inaweza kusaidia kwa urahisi kusawazisha, na unaweza kutumia amri ya saa kufuatilia mabadiliko.

Kwa hivyo baada ya kutekeleza amri ya kupeleka seva ya ukuzaji kwa programu yetu, tunaweza kutumia amri ifuatayo kwa usalama:

$ npx nodeshift watch

Matokeo yake, uunganisho utafanywa kwa pod inayoendesha ambayo tumeunda mapema kidogo, maingiliano ya faili zetu za ndani na kikundi cha mbali kitaanzishwa, na faili kwenye mfumo wetu wa ndani zitaanza kufuatiliwa kwa mabadiliko.

Kwa hivyo, ikiwa sasa tutasasisha faili ya src/App.js, mfumo utachukua hatua kwa mabadiliko haya, kuyanakili kwenye kundi la mbali na kuanzisha seva ya usanidi, ambayo itasasisha programu yetu kwenye kivinjari.

Ili kukamilisha picha, hebu tuonyeshe jinsi amri hizi zote zinavyoonekana:

$ 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

Amri ya saa ni kifupi juu ya amri ya oc rsync, unaweza kujifunza zaidi kuhusu jinsi inavyofanya kazi hapa.

Huu ulikuwa mfano wa React, lakini njia sawa inaweza kutumika na mifumo mingine, weka tu utofauti wa mazingira wa NPM_RUN inapohitajika.

Mabomba ya Openshift

Ifuatayo tutazungumza juu ya zana kama Mabomba ya OpenShift na jinsi inavyoweza kutumika kama njia mbadala ya ujenzi uliofungwa.

Mabomba ya OpenShift ni nini

OpenShift Pipelines ni mfumo unaoendelea wa ujumuishaji na uwasilishaji wa CI/CD wa wingu ulioundwa kwa ajili ya kupanga mabomba kwa kutumia Tekton. Tekton ni mfumo wa programu huria wa Kubernetes-asili wa CI/CD unaokuruhusu kusambaza kiotomatiki kwenye mifumo mbalimbali (Kubernetes, isiyo na seva, mashine pepe, n.k.) kwa kutoa kutoka kwa safu ya msingi.

Kuelewa kifungu hiki kunahitaji ujuzi fulani wa Pipelines, kwa hivyo tunapendekeza sana kwamba usome kwanza kitabu rasmi.

Kuweka mazingira yako ya kazi

Ili kucheza na mifano katika nakala hii, kwanza unahitaji kuandaa mazingira yako ya kufanya kazi:

Sakinisha na usanidi nguzo ya OpenShift 4. Mifano yetu hutumia CodeReady Containers (CRD) kwa hili, maagizo ya usakinishaji ambayo yanaweza kupatikana. hapa.
Baada ya nguzo iko tayari, unahitaji kusakinisha Opereta ya Bomba juu yake. Usiogope, ni rahisi, maagizo ya ufungaji hapa.
Download Tekton CLI (tkn) hapa.
Tekeleza zana ya amri ya kuunda-react-app ili kuunda programu ambayo utasambaza (hii ni programu rahisi Tenda).
(Hiari) Funga hazina ili kuendesha programu ya mfano ndani ya nchi na npm install kisha npm anza.

Hifadhi ya programu pia itakuwa na folda ya k8s, ambayo itakuwa na Kubernetes/OpenShift YAML zinazotumiwa kupeleka programu. Kutakuwa na Kazi, Kazi za Cluster, Rasilimali na Mabomba ambayo tutaunda katika hili hazina.

Tuanze

Hatua ya kwanza kwa mfano wetu ni kuunda mradi mpya katika nguzo ya OpenShift. Wacha tuite mradi huu webapp-pipeline na tuunde kwa amri ifuatayo:

$ oc new-project webapp-pipeline

Jina la mradi huu litaonekana kwenye msimbo baadaye, kwa hivyo ukiamua kuupa jina lingine, usisahau kuhariri msimbo wa mfano ipasavyo. Kuanzia hatua hii, hatutaenda juu-chini, lakini chini-juu: yaani, kwanza tutaunda vipengele vyote vya conveyor, na kisha tu conveyor yenyewe.

Kwa hivyo, kwanza kabisa ...

Kazi

Wacha tuunde kazi kadhaa, ambazo zitasaidia kupeleka programu ndani ya bomba letu. Kazi ya kwanza - apply_manifests_task - inawajibika kwa kutumia YAML ya rasilimali hizo za Kubernetes (huduma, usambazaji na njia) ambazo ziko kwenye folda ya k8s ya programu yetu. Kazi ya pili - update_deployment_task - inawajibika kusasisha picha ambayo tayari imetumwa kwa ile iliyoundwa na bomba letu.

Usijali ikiwa bado haijaeleweka sana. Kwa kweli, kazi hizi ni kitu kama huduma, na tutaziangalia kwa undani zaidi baadaye kidogo. Kwa sasa, wacha tuyaunde:

$ 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

Kisha, kwa kutumia tkn CLI amri, tutaangalia kwamba kazi zimeundwa:

$ tkn task ls

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

Kumbuka: Hizi ni kazi za karibu kwa mradi wako wa sasa.

Kazi za nguzo

Kazi za nguzo kimsingi ni sawa na kazi rahisi. Hiyo ni, ni mkusanyiko wa hatua zinazoweza kutumika tena ambazo zimeunganishwa kwa njia moja au nyingine wakati wa kufanya kazi maalum. Tofauti ni kwamba kazi ya nguzo inapatikana kila mahali ndani ya nguzo. Ili kuona orodha ya kazi za nguzo ambazo zinaundwa kiotomatiki wakati wa kuongeza Opereta ya Bomba, tutatumia tena tkn CLI amri:

$ 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

Sasa hebu tuunde kazi mbili za nguzo. Ya kwanza itazalisha picha ya S2I na kuituma kwa sajili ya ndani ya OpenShift; pili ni kujenga taswira yetu kulingana na NGINX, kwa kutumia programu ambayo tayari tumeijenga kama yaliyomo.

Unda na utume picha

Wakati wa kuunda kazi ya kwanza, tutarudia kile tulichofanya tayari katika makala iliyotangulia kuhusu makusanyiko yaliyounganishwa. Kumbuka kwamba tulitumia picha ya S2I (ubi8-s2i-web-app) "kujenga" programu yetu, na tukaishia na picha iliyohifadhiwa katika sajili ya ndani ya OpenShift. Sasa tutatumia picha hii ya programu ya wavuti ya S2I kuunda DockerFile ya programu yetu na kisha kutumia Buildah kufanya uundaji halisi na kusukuma picha inayotokana na usajili wa ndani wa OpenShift, kwani ndivyo OpenShift hufanya unapotuma programu zako kwa kutumia NodeShift. .

Tulijuaje haya yote, unauliza? Kutoka toleo rasmi la Node.js rasmi, tumeinakili na kuirekebisha kwa ajili yetu wenyewe.

Kwa hivyo, sasa hebu tuunde kazi ya nguzo ya s2i-wavuti-programu:

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

Hatutachambua hili kwa undani, lakini tutazingatia tu kigezo cha OUTPUT_DIR:

params:
      - name: OUTPUT_DIR
        description: The location of the build output directory
        default: build

Kwa chaguo-msingi, parameta hii ni sawa na kujenga, ambapo React inaweka maudhui yaliyokusanywa. Mifumo mingine hutumia njia tofauti, kwa mfano, katika Ember ni dist. Matokeo ya kazi yetu ya kwanza ya nguzo itakuwa picha iliyo na HTML, JavaScript, na CSS tuliyokusanya.

Unda picha kulingana na NGINX

Kuhusu kazi yetu ya pili ya nguzo, inapaswa kutujengea picha inayotokana na NGINX, kwa kutumia maudhui ya programu ambayo tayari tumejenga. Kimsingi, hii ni sehemu ya sehemu iliyopita ambapo tuliangalia ujenzi wa minyororo.

Ili kufanya hivyo, sisi - sawa na hapo juu - tutaunda kazi ya nguzo webapp-build-runtime:

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

Ukiangalia msimbo wa kazi hizi za nguzo, unaweza kuona kwamba haubainishi hazina ya Git tunayofanya kazi nayo au majina ya picha tunazounda. Tunabainisha tu ni nini hasa tunahamisha kwa Git, au picha fulani ambapo picha ya mwisho inapaswa kutolewa. Hii ndiyo sababu kazi hizi za nguzo zinaweza kutumika tena wakati wa kufanya kazi na programu zingine.

Na hapa tunasonga mbele kwa hatua inayofuata ...

Rasilimali

Kwa hivyo, kwa kuwa, kama tulivyosema hivi punde, kazi za nguzo zinapaswa kuwa za jumla iwezekanavyo, tunahitaji kuunda rasilimali ambazo zitatumika kama pembejeo (hazina ya Git) na kama pato (picha za mwisho). Rasilimali ya kwanza tunayohitaji ni Git, ambapo maombi yetu yanakaa, kitu kama hiki:

# 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

Hapa PipelineResource ni ya aina ya git. Kitufe cha url katika sehemu ya params kinaelekeza kwenye hazina maalum na kubainisha tawi kuu (hii ni hiari, lakini tunaiandika kwa ukamilifu).

Sasa tunahitaji kuunda rasilimali kwa picha ambapo matokeo ya kazi ya s2i-web-programu yatahifadhiwa, hii inafanywa kama hii:

# 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

Hapa Rasilimali ya Pipeline ni ya aina ya picha, na thamani ya parameta ya url inaelekeza kwenye Usajili wa Picha wa OpenShift wa ndani, haswa ile iliyoko kwenye nafasi ya majina ya bomba la wavuti. Usisahau kubadilisha mpangilio huu ikiwa unatumia nafasi tofauti ya majina.

Na mwishowe, rasilimali ya mwisho tunayohitaji pia itakuwa ya aina ya picha na hii itakuwa picha ya mwisho ya NGINX ambayo itatumika wakati wa kupelekwa:

# 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

Tena, kumbuka kuwa rasilimali hii huhifadhi picha kwenye sajili ya ndani ya OpenShift kwenye nafasi ya majina ya bomba la wavuti.

Ili kuunda rasilimali hizi zote mara moja, tunatumia amri ya kuunda:

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

Unaweza kuhakikisha kuwa rasilimali zimeundwa kama hii:

$ tkn resource ls

Bomba la conveyor

Sasa kwa kuwa tunayo vipengele vyote muhimu, hebu tukusanye bomba kutoka kwao kwa kuunda kwa amri ifuatayo:

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

Lakini kabla ya kutekeleza amri hii, hebu tuangalie vipengele hivi. Ya kwanza ni jina:

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

Halafu katika sehemu maalum tunaona dalili ya rasilimali tulizounda hapo awali:

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

Kisha tunaunda majukumu ambayo bomba letu linahitaji kukamilisha. Kwanza kabisa, ni lazima itekeleze kazi ya s2i-web-app ambayo tayari tumeunda:

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

Kazi hii inachukua pembejeo (rasilimali ya gir) na pato (rasilimali ya picha iliyojengwa-ya-programu-ya-tumizi). Pia tunaipitisha kigezo maalum ili isithibitishe TLS kwa kuwa tunatumia vyeti vya kujisajili wenyewe:

resources:
        inputs:
          - name: source
            resource: web-application-repo
        outputs:
          - name: image
            resource: built-web-application-image
      params:
        - name: TLSVERIFY
          value: "false"

Kazi inayofuata ni sawa, hapa tu kazi ya nguzo ya webapp-build-runtime ambayo tayari tumeunda inaitwa:

name: build-runtime-image
    taskRef:
      name: webapp-build-runtime
      kind: ClusterTask

Kama ilivyo kwa kazi iliyotangulia, tunapita kwenye rasilimali, lakini sasa ni picha ya programu-tumizi iliyojengwa (matokeo ya kazi yetu ya awali). Na kama pato sisi tena kuweka picha. Kwa kuwa kazi hii lazima itekelezwe baada ya ile ya awali, tunaongeza runAfter field:

resources:
        inputs:
          - name: image
            resource: built-web-application-image
        outputs:
          - name: image
            resource: runtime-web-application-image
        params:
        - name: TLSVERIFY
          value: "false"
      runAfter:
        - build-web-application

Kazi mbili zinazofuata zinawajibika kwa kutumia huduma, njia na uwekaji faili za YAML ambazo zinaishi katika saraka ya k8s ya programu yetu ya wavuti, na pia kusasisha utumiaji huu wakati wa kuunda picha mpya. Tulifafanua kazi hizi mbili za nguzo mwanzoni mwa makala.

Kuanzisha conveyor

Kwa hivyo, sehemu zote za bomba zetu zimeundwa, na tutaendesha kwa amri ifuatayo:

$ tkn pipeline start build-and-deploy-react

Katika hatua hii, safu ya amri inatumiwa kwa maingiliano na unahitaji kuchagua rasilimali zinazofaa kujibu kila ombi lake: kwa rasilimali ya git, chagua programu-tumizi ya wavuti, kisha kwa rasilimali ya kwanza ya picha, programu iliyojengwa ya wavuti. -image, na hatimaye, kwa rasilimali ya pili ya picha -runtime-web-application-picha:

? 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

Sasa hebu tuangalie hali ya bomba kwa kutumia amri ifuatayo:

$ tkn pipeline logs -f

Mara tu bomba limeanza na programu imetumwa, tunaweza kuomba njia iliyochapishwa kwa amri ifuatayo:

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

Kwa taswira kubwa zaidi, unaweza kuona bomba letu katika hali ya Msanidi wa dashibodi ya wavuti katika sehemu hiyo Mabomba, kama inavyoonyeshwa kwenye Mtini. 1.

Mtini.1. Mapitio ya bomba zinazoendesha.

Kubofya kwenye bomba linaloendesha huonyesha maelezo ya ziada, kama inavyoonyeshwa kwenye Mchoro 2.

Mchele. 2. Maelezo ya ziada kuhusu bomba.

Baada ya maelezo zaidi, unaweza kuona programu zinazoendesha kwenye mwonekano topology, kama inavyoonyeshwa kwenye Mtini.3.

Kielelezo 3. Poda iliyozinduliwa.

Kubofya kwenye mduara kwenye kona ya juu kulia ya ikoni hufungua programu yetu, kama inavyoonyeshwa kwenye Mchoro 4.

Mchele. 4. Kuendesha programu ya React.

Hitimisho

Kwa hivyo, tulionyesha jinsi ya kuendesha seva ya ukuzaji kwa programu yako kwenye OpenShift na kuisawazisha na mfumo wa faili wa ndani. Tuliangalia pia jinsi ya kuiga kiolezo cha kujenga minyororo kwa kutumia Mabomba ya OpenShift. Nambari zote za mfano kutoka kwa nakala hii zinaweza kupatikana hapa.

Nyenzo za ziada (EN)

Matangazo ya mitandao ijayo

Tunaanzisha mfululizo wa kurasa za wavuti za Ijumaa kuhusu matumizi asilia kwa kutumia Jukwaa la Kontena la Red Hat OpenShift na Kubernetes:

Chanzo: mapenzi.com

Programu za kisasa kwenye OpenShift, sehemu ya 3: OpenShift kama mazingira ya ukuzaji na Mabomba ya OpenShift