🥇 Téigh? Bash! Téigh in aithne ar an oibreoir bhlaosc (tuarascáil athbhreithnithe agus físeáin ó KubeCon EU'2020)

I mbliana, bhí príomh-chomhdháil Eorpach Kubernetes - KubeCon + CloudNativeCon Europe 2020 - fíorúil. Mar sin féin, níor chuir a leithéid d’athrú formáide cosc orainn ár dtuarascáil fhadphleanáilte “Go? Bash! Téigh in aithne ar Shell-oibreoir” tiomnaithe dár dtionscadal Foinse Oscailte sliogán-oibreoir.

Cuireann an t-alt seo, arna spreagadh ag an gcaint, cur chuige i láthair chun an próiseas cruthaithe oibreoirí do Kubernetes a shimpliú agus taispeánann sé conas is féidir leat do chuid féin a dhéanamh gan mórán iarrachta ag baint úsáide as oibreoir sliogán.

Ag tabhairt isteach físeán den tuarascáil (~23 nóiméad i mBéarla, go suntasach níos faisnéiseach ná an t-alt) agus an príomhshliocht as i bhfoirm téacs. Téigh!

Ag Flant déanaimid gach rud a bharrfheabhsú agus a uathoibriú i gcónaí. Sa lá atá inniu beimid ag caint faoi choincheap spreagúil eile. Buail le: scriptithe bhlaosc dúchais scamall!

Mar sin féin, déanaimis tosú leis an gcomhthéacs ina dtarlaíonn sé seo go léir: Kubernetes.

Kubernetes API agus rialaitheoirí

Is féidir an API i Kubernetes a léiriú mar chineál freastalaí comhaid le heolairí do gach cineál réad. Déanann comhaid YAML ionadaíocht ar réada (acmhainní) ar an bhfreastalaí seo. Ina theannta sin, tá API bunúsach ag an bhfreastalaí a ligeann duit trí rud a dhéanamh:

fháil acmhainn de réir a cineáil agus a hainm;
athrú acmhainn (sa chás seo, ní stórálann an freastalaí ach réada “cearta” - caitear amach gach ceann a foirmíodh go mícheart nó a bheartaítear d’eolairí eile);
rian don acmhainn (sa chás seo, faigheann an t-úsáideoir a leagan reatha/nuashonraithe láithreach).

Mar sin, feidhmíonn Kubernetes mar chineál freastalaí comhad (le haghaidh manifests YAML) le trí mhodh bhunúsacha (tá, i ndáiríre tá cinn eile ann, ach fágfaimid ar lár iad faoi láthair).

Is í an fhadhb atá ann ná nach féidir leis an bhfreastalaí ach faisnéis a stóráil. Chun é a dhéanamh ag obair is gá duit rialtóir - an dara coincheap is tábhachtaí agus is bunúsaí i saol na Kubernetes.

Tá dhá phríomhchineál rialtóirí ann. Glacann an chéad cheann faisnéis ó Kubernetes, próiseálann sé de réir loighic neadaithe, agus cuireann sé ar ais chuig K8anna í. Glacann an dara ceann faisnéis ó Kubernetes, ach, murab ionann agus an chéad chineál, athraíonn sé staid roinnt acmhainní seachtracha.

Breathnaímid ar an bpróiseas chun Imscaradh a chruthú i Kubernetes:

Rialaitheoir Imlonnaithe (san áireamh i kube-controller-manager) faigheann sé eolas faoi Imscaradh agus cruthaíonn sé ReplicaSet.
Cruthaíonn ReplicaSet dhá mhacasamhail (dhá pods) bunaithe ar an bhfaisnéis seo, ach níl na pods seo sceidealaithe fós.
Déanann an sceidealóir pods a sceidealú agus cuireann sé faisnéis nóid lena n-YAMLanna.
Déanann Kubelets athruithe ar acmhainn sheachtrach (abair Docker).

Ansin déantar an t-ord iomlán seo a athdhéanamh in ord droim ar ais: seiceann an kubelet na coimeádáin, ríomhann sé stádas an choda agus cuireann sé ar ais é. Faigheann an rialtóir ReplicaSet an stádas agus nuashonraíonn sé staid an tacair macasamhail. Tarlaíonn an rud céanna leis an Rialaitheoir Imscaradh agus faigheann an t-úsáideoir an stádas nuashonraithe (reatha) ar deireadh.

Blaosc-oibreoir

Tharlaíonn sé go raibh Kubernetes bunaithe ar chomhobair na rialtóirí éagsúla (tá oibreoirí Kubernetes freisin rialaitheoirí). Éiríonn an cheist, conas do oibreoir féin a chruthú le hiarracht íosta? Agus anseo tagann an ceann a d'fhorbair muid chun an tarrthála sliogán-oibreoir. Ligeann sé do riarthóirí córais a ráitis féin a chruthú ag baint úsáide as modhanna coitianta.

Sampla simplí: rúin a chóipeáil

Breathnaímid ar shampla simplí.

Ligean le rá go bhfuil braisle Kubernetes againn. Tá spás ainm air default le roinnt Rúnda mysecret. Ina theannta sin, tá spásanna ainmneacha eile sa bhraisle. Tá lipéad ar leith ceangailte le cuid acu. Is é ár gcuspóir Rúnda a chóipeáil isteach i spásanna ainm le lipéad.

Is casta an tasc toisc go bhféadfadh spásanna ainmneacha nua a bheith le feiceáil sa bhraisle, agus seans go mbeidh an lipéad seo ar chuid acu. Ar an láimh eile, nuair a scriostar an lipéad, ba cheart Rúnda a scriosadh freisin. Ina theannta sin, is féidir leis an Rúnda féin a athrú freisin: sa chás seo, ní mór an Rúnda nua a chóipeáil chuig gach ainmspás le lipéid. Má scriostar Rúnda de thaisme in aon ainmspás, ba cheart dár n-oibreoir é a chur ar ais láithreach.

Anois go bhfuil an tasc curtha le chéile, tá sé in am tosú ag baint úsáide as an bhlaosc-oibreoir. Ach ar dtús is fiú cúpla focal a rá faoin oibreoir bhlaosc féin.

Conas a oibríonn blaosc-oibreoir

Cosúil le hualaí oibre eile i Kubernetes, ritheann blaosc-oibreoir ina phod féin. Sa pod seo sa eolaire /hooks stóráiltear comhaid inrite. Is féidir iad seo a bheith ina scripteanna i Bash, Python, Ruby, etc. Glaoimid crúcaí comhaid inrite dá leithéid (crúcaí).

Síníonn Shell-operator le himeachtaí Kubernetes agus ritheann sé na crúcaí seo mar fhreagra ar na himeachtaí sin a theastaíonn uainn.

Cén chaoi a bhfuil a fhios ag an oibreoir sliogán cén duán le rith agus cathain? Is é an pointe go bhfuil dhá chéim ag gach hook. Le linn tosaithe, ritheann an bhlaosc-oibreoir gach crúcaí le argóint --config Is é seo an chéim chumraíochta. Agus tar éis é, seoltar crúcaí ar an ngnáthbhealach - mar fhreagra ar na himeachtaí a bhfuil siad ag gabháil leo. Sa chás deiridh sin, faigheann an duán an comhthéacs ceangailteach (comhthéacs ceangailteach) - sonraí i bhformáid JSON, a labhróimid faoi níos mine thíos.

Oibreoir a dhéanamh i Bash

Anois táimid réidh le cur i bhfeidhm. Chun seo a dhéanamh, ní mór dúinn dhá fheidhm a scríobh (dála an scéil, molaimid leabharlann sliogán_lib, rud a shimplíonn go mór crúcaí scríbhneoireachta i Bash):

tá an chéad cheann ag teastáil don chéim chumraíochta - taispeánann sé an comhthéacs ceangailteach;
sa dara ceann tá an loighic is mó de na Hook.

#!/bin/bash

source /shell_lib.sh

function __config__() {
  cat << EOF
    configVersion: v1
    # BINDING CONFIGURATION
EOF
}

function __main__() {
  # THE LOGIC
}

hook::run "$@"

Is é an chéad chéim eile cinneadh a dhéanamh ar na rudaí a theastaíonn uainn. Inár gcás, ní mór dúinn a rianú:

foinse rúnda le haghaidh athruithe;
gach ainmspás sa bhraisle, ionas go mbeidh a fhios agat cé na cinn a bhfuil lipéad ceangailte orthu;
sprioc-rúin chun a chinntiú go bhfuil siad ar fad ag teacht le rún na foinse.

Liostáil leis an bhfoinse rúnda

Tá cumraíocht cheangailteach dó simplí go leor. Cuirimid in iúl go bhfuil suim againn i Rúnda leis an ainm mysecret in ainmspás default:

function __config__() {
  cat << EOF
    configVersion: v1
    kubernetes:
    - name: src_secret
      apiVersion: v1
      kind: Secret
      nameSelector:
        matchNames:
        - mysecret
      namespace:
        nameSelector:
          matchNames: ["default"]
      group: main
EOF

Mar thoradh air sin, spreagfar an duán nuair a athraíonn rún na foinse (src_secret) agus gheobhaidh siad an comhthéacs ceangailteach seo a leanas:

Mar a fheiceann tú, tá an t-ainm agus an réad ar fad ann.

Súil a choinneáil ar spásanna ainmneacha

Anois ní mór duit liostáil le spásanna ainmneacha. Chun seo a dhéanamh, sonraímid an chumraíocht cheangailteach seo a leanas:

- name: namespaces
  group: main
  apiVersion: v1
  kind: Namespace
  jqFilter: |
    {
      namespace: .metadata.name,
      hasLabel: (
       .metadata.labels // {} |  
         contains({"secret": "yes"})
      )
    }
  group: main
  keepFullObjectsInMemory: false

Mar a fheiceann tú, tá réimse nua le feiceáil sa chumraíocht leis an ainm jq Scagaire. Mar a thugann a ainm le fios, jqFilter scagann sé amach gach faisnéis neamhriachtanach agus cruthaítear oibiacht JSON nua leis na réimsí a bhfuil suim againn iontu. Gheobhaidh duán le cumraíocht chomhchosúil an comhthéacs ceangailteach seo a leanas:

Tá eagar ann filterResults do gach ainmspás sa bhraisle. Athróg Boole hasLabel léiríonn an bhfuil lipéad ceangailte d'ainmspás tugtha. Roghnóir keepFullObjectsInMemory: false léiríonn sé nach bhfuil aon ghá rudaí iomlána a choinneáil i gcuimhne.

Rianú rúin sprioc

Déanaimid liostáil le gach Rúin a bhfuil nóta sonraithe acu managed-secret: "yes" (Is iad seo ár sprioc dst_secrets):

- name: dst_secrets
  apiVersion: v1
  kind: Secret
  labelSelector:
    matchLabels:
      managed-secret: "yes"
  jqFilter: |
    {
      "namespace":
        .metadata.namespace,
      "resourceVersion":
        .metadata.annotations.resourceVersion
    }
  group: main
  keepFullObjectsInMemory: false

Sa chás seo jqFilter scagairí amach an fhaisnéis go léir ach amháin an t-ainmspás agus paraiméadar resourceVersion. Cuireadh an paraiméadar deireanach ar aghaidh chuig an nóta agus an rún á chruthú: ligeann sé duit leaganacha de rúin a chur i gcomparáid agus iad a choinneáil cothrom le dáta.

Gheobhaidh duán a bheidh cumraithe ar an mbealach seo, nuair a dhéantar é, na trí chomhthéacs ceangailteacha a gcuirtear síos orthu thuas. Is féidir smaoineamh orthu mar chineál pictiúr (léargas) cnuasach.

Bunaithe ar an eolas seo go léir, is féidir algartam bunúsach a fhorbairt. Déanann sé atriall thar gach ainmspás agus:

más rud é go hasLabel nithe true don ainmspás reatha:
- cuireann sé an rún domhanda i gcomparáid leis an rún áitiúil:
  - má tá siad mar an gcéanna, ní dhéanann sé faic;
  - má tá siad difriúil - fhorghníomhú kubectl replace nó create;
más rud é go hasLabel nithe false don ainmspás reatha:
- déanann sé cinnte nach bhfuil Rún san ainmspás tugtha:
  - má tá an Rúnda áitiúil i láthair, scrios é ag baint úsáide as kubectl delete;
  - mura n-aimsítear an Rúnda áitiúil, ní dhéanann sé faic.

Cur i bhfeidhm an algartam i Bash Is féidir leat a íoslódáil i ár stórtha le samplaí.

Sin é an chaoi a raibh muid in ann rialtóir Kubernetes simplí a chruthú ag baint úsáide as 35 líne de chumraíocht YAML agus thart ar an méid céanna cód Bash! Is é post an oibritheora sliogáin ná iad a nascadh le chéile.

Mar sin féin, ní hé cóipeáil rúin an t-aon réimse feidhme atá ag an bhfóntas. Seo roinnt samplaí eile lena thaispeáint cad atá sé in ann.

Sampla 1: Athruithe a dhéanamh ar ConfigMap

Breathnaímid ar Imscaradh comhdhéanta de thrí pods. Úsáideann pods ConfigMap chun roinnt cumraíochta a stóráil. Nuair a seoladh na pods, bhí ConfigMap i staid áirithe (cuirimis glaoch v.1 air). Dá réir sin, úsáideann gach pods an leagan áirithe seo de ConfigMap.

Anois glacaimis leis go bhfuil an ConfigMap athraithe (v.2). Mar sin féin, úsáidfidh na pods an leagan roimhe seo de ConfigMap (v.1):

Conas is féidir liom iarraidh orthu aistriú go dtí an ConfigMap (v.2) nua? Is é an freagra simplí: úsáid teimpléad. Cuirimis nóta seiceála leis an rannán template Cumraíochtaí imlonnaithe:

Mar thoradh air sin, clárófar an seiceála seo i ngach pods, agus beidh sé mar an gcéanna leis an Imscaradh. Anois ní gá duit ach an nóta a nuashonrú nuair a athraíonn an ConfigMap. Agus tagann an bhlaosc-oibreoir i handy sa chás seo. Níl le déanamh agat ach an clár duán a liostóidh leis an ConfigMap agus a nuashonróidh an tseic.

Má dhéanann an t-úsáideoir athruithe ar an ConfigMap, tabharfaidh an t-oibreoir blaosc faoi deara iad agus déanfaidh sé an tseic a athríomh. Ina dhiaidh sin tiocfaidh draíocht Kubernetes i spraoi: maróidh an ceolfhoireann an pod, cruthóidh sé ceann nua, fanfaidh sé Ready, agus bogann sé ar aghaidh go dtí an chéad cheann eile. Mar thoradh air sin, déanfaidh Imscaradh sioncronú agus athrú go dtí an leagan nua de ConfigMap.

Sampla 2: Ag Obair le Sainmhínithe Acmhainní Saincheaptha

Mar is eol duit, ligeann Kubernetes duit cineálacha saincheaptha rudaí a chruthú. Mar shampla, is féidir leat cineál a chruthú MysqlDatabase. Ligean le rá go bhfuil dhá pharaiméadar meiteashonraí ag an gcineál seo: name и namespace.

apiVersion: example.com/v1alpha1
kind: MysqlDatabase
metadata:
  name: foo
  namespace: bar

Tá braisle Kubernetes againn le spásanna éagsúla ainmneacha inar féidir linn bunachair shonraí MySQL a chruthú. Sa chás seo is féidir blaosc-oibreoir a úsáid chun acmhainní a rianú MysqlDatabase, iad a nascadh leis an bhfreastalaí MySQL agus na stáit inmhianaithe agus breathnaithe den bhraisle a shioncronú.

Sampla 3: Monatóireacht ar Ghréasán Cnuasaigh

Mar is eol duit, is é ping an bealach is simplí chun monatóireacht a dhéanamh ar líonra. Sa sampla seo taispeánfaimid conas monatóireacht den sórt sin a chur i bhfeidhm ag baint úsáide as blaosc-oibreoir.

Gcéad dul síos, beidh ort síntiús a íoc le nóid. Caithfidh an t-oibreoir bhlaosc ainm agus seoladh IP gach nód. Le cabhair uathu, beidh sé ag ping na nóid seo.

configVersion: v1
kubernetes:
- name: nodes
  apiVersion: v1
  kind: Node
  jqFilter: |
    {
      name: .metadata.name,
      ip: (
       .status.addresses[] |  
        select(.type == "InternalIP") |
        .address
      )
    }
  group: main
  keepFullObjectsInMemory: false
  executeHookOnEvent: []
schedule:
- name: every_minute
  group: main
  crontab: "* * * * *"

Paraiméadar executeHookOnEvent: [] cosc ar an hook ó rith mar fhreagra ar aon imeacht (is é sin, mar fhreagra ar athrú, cur, nóid a scriosadh). Mar sin féin, sé rithfidh (agus nuashonraigh liosta na nóid) Sceidealta - gach nóiméad, mar atá forordaithe ag an réimse schedule.

Anois tá an cheist, cad é go díreach atá ar eolas againn faoi fhadhbanna cosúil le caillteanas paicéad? Breathnaímid ar an gcód:

function __main__() {
  for i in $(seq 0 "$(context::jq -r '(.snapshots.nodes | length) - 1')"); do
    node_name="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.name')"
    node_ip="$(context::jq -r '.snapshots.nodes['"$i"'].filterResult.ip')"
    packets_lost=0
    if ! ping -c 1 "$node_ip" -t 1 ; then
      packets_lost=1
    fi
    cat >> "$METRICS_PATH" <<END
      {
        "name": "node_packets_lost",
        "add": $packets_lost,
        "labels": {
          "node": "$node_name"
        }
      }
END
  done
}

Déanaimid athrá tríd an liosta nóid, faighimid a n-ainmneacha agus a seoltaí IP, cuirimid iad i bping agus cuirimid na torthaí chuig Prometheus. Is féidir le hoibreoir bhlaosc méadracht a onnmhairiú go Prometheus, iad a shábháil ar chomhad atá suite de réir an chosáin a shonraítear san athróg timpeallachta $METRICS_PATH.

Anseo mar sin is féidir leat oibreoir a dhéanamh le haghaidh monatóireachta líonra simplí i mbraisle.

Meicníocht scuaine

Bheadh an t-alt seo neamhiomlán gan cur síos a dhéanamh ar mheicníocht thábhachtach eile a cuireadh san áireamh san oibreoir blaosc. Samhlaigh go ndéanann sé duán de chineál éigin a fhorghníomhú mar fhreagra ar imeacht sa bhraisle.

Cad a tharlaíonn má tharlaíonn rud éigin sa bhraisle ag an am céanna? Eile imeacht?
An rithfidh an t-oibreoir sliogán sampla eile den duán?
Cad a tharlaíonn má tharlaíonn, abair, cúig eachtra sa chnuasach ag an am céanna?
An bpróiseálfaidh an t-oibreoir blaosc iad go comhthreomhar?
Cad faoi acmhainní ídithe ar nós cuimhne agus LAP?

Ar ámharaí an tsaoil, tá meicníocht scuaine ionsuite ag an oibreoir sliogán. Déantar gach imeacht a scuaine agus a phróiseáil go seicheamhach.

Léirímid é seo le samplaí. Ligean le rá go bhfuil dhá crúca againn. Téann an chéad imeacht go dtí an chéad Hook. Nuair a bheidh a phróiseáil críochnaithe, bogann an scuaine ar aghaidh. Atreoraítear na chéad trí imeacht eile chuig an dara duán - baintear as an scuaine iad agus cuirtear isteach ann i “gcuad”. Is é sin Faigheann Hook sraith imeachtaí - nó, níos cruinne, raon comhthéacsanna ceangailteacha.

Chomh maith leis sin is féidir imeachtaí a chomhcheangal i gceann mór. Tá an paraiméadar freagrach as seo group sa chumraíocht cheangailteach.

Is féidir leat líon ar bith scuainí/dubháin agus a dteaglaim éagsúla a chruthú. Mar shampla, is féidir le scuaine amháin oibriú le dhá crúcaí, nó vice versa.

Níl le déanamh ach an réimse a chumrú dá réir queue sa chumraíocht cheangailteach. Mura sonraítear ainm scuaine, ritheann an duán sa scuaine réamhshocraithe (default). Ligeann an mheicníocht scuaine seo duit gach fadhb bainistíochta acmhainne a réiteach go hiomlán agus tú ag obair le crúcaí.

Conclúid

Mhínigh muid cad is blaosc-oibreoir ann, léirigh muid conas is féidir é a úsáid chun oibreoirí Kubernetes a chruthú go tapa agus gan stró, agus thugamar roinnt samplaí dá úsáid.

Tá faisnéis mhionsonraithe faoin oibreoir blaosc, chomh maith le teagasc tapa ar conas é a úsáid, ar fáil sa chomhfhreagras stórtha ar GitHub. Ná bíodh leisce ort teagmháil a dhéanamh linn le ceisteanna: is féidir leat iad a phlé go speisialta Grúpa teileagraim (i Rúisis) nó i fóram seo (i mBéarla).

Agus má thaitin sé leat, táimid i gcónaí sásta saincheisteanna nua / PR / réaltaí a fheiceáil ar GitHub, áit ar féidir leat, dála an scéil, daoine eile a aimsiú tionscadail suimiúla. Ina measc is fiú aird a tharraingt addon-oibreoir, arb é deartháir mór an t-oibreoir sliogán é. Úsáideann an áirgiúlacht seo cairteacha Helm chun breiseáin a shuiteáil, is féidir leo nuashonruithe a sheachadadh agus monatóireacht a dhéanamh ar pharaiméadair/luachanna cairte éagsúla, rialaíonn sé próiseas suiteála na gcairteacha, agus féadann sé iad a mhodhnú freisin mar fhreagra ar imeachtaí sa bhraisle.

Físeáin agus sleamhnáin

Físeán ón léiriú (~23 nóiméad):

Cur i láthair na tuarascála:

PS

Léigh freisin ar ár mblag:

Foinse: will.com

Téigh? Bash! Buail leis an oibreoir sliogán (tuairisc athbhreithnithe agus físeáin ó KubeCon EU'2020)