Waiting: Ang Subtle Art na Kailangan mong Master

Recently, while working on a workshop titled I-test ang iyong Pull Request sa Kubernetes gamit ang GKE at GitHub Actions, I've faced the same problem twice: service A needs service B, ngunit service A ay nagsisimula mas mabilis kaysa sa service B, at ang sistema ay hindi.

Paglalarawan ng Kubernetes

Ito ay maaaring magiging mahirap upang maghintay sa Kubernetes. Ang self-healing nature ng Kubernetes platform ay isa sa mga pinakamalaking katangian nito. Makikita natin ang dalawang pods: isang application ng Python at isang database ng PostgreSQL.

Ang application ay nagsisimula na mas mabilis at nangangailangan upang lumikha ng isang koneksyon sa database. Samakatuwid, ang database ay nagsisimula sa sarili na may ang mga data na ibinigay; ang koneksyon ay nangangailangan.Failedang estado.

Pagkatapos ng ilang oras, ang Kubernetes ay nag-aalok ang estado ng application pod. Dahil ito ay nangangahulugan, itinatag ito at nagsimula ng isang bagong pod. Sa oras na ito, dalawang bagay ay maaaring lumikha: ang database pod ay hindi nagtatapos na, at ito ay bumalik sa square one, o ito ay nagtatapos, at ang application ay humahantong mag-connect.

Upang i-accelerate ang proseso, ang Kubernetes ay nag-aalokMga Probeang :

startupProbe:
  httpGet:
    path: /health
    port: 8080
  failureThreshold: 30
  periodSeconds: 10

Sa pamamagitan ng paglalarawan sa itaas, ang Kubernetes ay naghintay para sa isang unang tatlong segundo bago ang pag-request ng estado ng pod. Kung ito ay hindi gumagana, ito ay naghintay para sa higit sa tatlong sekundo.

Maaari kang makita ang HTTP/healthIpinapakita ng Kubernetes ang dalawang exclusivepagsusuriAng mga configuration:httpGeto saexecAng unang ay magagamit para sa mga web application, habang ang ikalawang ay para sa iba pang mga application. Ito ay nangangahulugan na kailangan nating malaman kung ano ang uri ng container ang pod ay naglalaman at kung paano upang i-check ang kanyang status, kung ito ay maaaring. Ako ay hindi PostgreSQL expert, kaya ako naghahanap para sa isang estado check command.Mga pahinang tumuturo sa Helm ChartIto ay tulad ng mga sumusunod kapag ito ay ginagamit:

startupProbe:
  exec:
    command:
      - /bin/sh
      - -c
      - -e
      - exec pg_isready -U $PG_USER -h $PG_HOST -p $PG_PORT

Tingnan na ang ibig sabihin ng itaas ay isang pag-usapan, dahil ito ay masaya ang pangalan ng database at isang SSL certificate.

Ang startup probe accelerates things up compared to the default situation if you configure it properly. You can set a long initial delay, at pagkatapos ay mas mababang increments. Gayunpaman, ang mas diversified ang mga containers, mas mahirap ito upang i-configure, dahil kailangan mong maging isang eksperto sa bawat ng mga pangunahing containers.

Ito ay magagawa ng paghahanap ng alternatibo.

sa pamamagitan ng 4x

Ang mga alternatibo ay mga tool na ang focus ay sa pag-atake. Ilang taon na ang nakalipas, nakita ko angMaghintay saAng mga ito ay magkakaiba. ang ideya ay simple:

sa loob

./wait-for ay isang script na dinisenyo upang i-synchronize ang mga serbisyo tulad ng docker containers. Ito ay sh at alpine compatible.

sa loob

./wait-foray isang script na dinisenyo upang i-synchronize ang mga serbisyo tulad ng docker containers.shat angalpineang compatible.

Narito ang kung paano maghintay para sa isang HTTP API:

sh -c './wait-for http://my.api/health -- echo "The api is up! Let's use it"'

Ito ay ginawa ang trabaho, ngunit sa oras na ito, kailangan mong i-copy ang script at manually check para sa mga update. I've checked, at ang proyekto ngayon ay nagbibigay ng isang regular na container.

sa pamamagitan ng 4xgumagana ang parehong papel, ngunit ay magagamit bilang isang versioned container at nagbibigay ng higit pa ng mga serbisyo na maghintay para sa: HTTP, DNS, databases, at message queues.

Kung ano ang tool mo ginagamit, maaari mong gamitin ito sa isangMga Containerang :

sa loob

Ang isang Pod ay maaaring magkaroon ng maraming containers na gumagana ng apps sa kanya, ngunit ito ay maaaring magkaroon ng isa o higit pa ng init containers, na ginagamit bago ang app containers ay nagsisimula.

sa loob

Init containers ay regular na containers, isip na:

sa loob

Init containers always run to completion. Ang bawat init container ay dapat na kumpletong bago ang next one ay nagsimula.

sa loob

Ang isang Pod ay maaaring magkaroon ng maraming containers na gumagana ng apps sa kanya, ngunit ito ay maaaring magkaroon ng isa o higit pa ng init containers, na ginagamit bago ang app containers ay nagsisimula.

Init containers ay regular na containers, isip na:

Init containers always run to completion. Ang bawat init container ay dapat na kumpletong bago ang next one ay nagsimula.

Imagine ang mga sumusunodPodIto ay depende sa PostgreSQLDeploymentang :

apiVersion: v1
kind: Pod
metadata:
  labels:
    type: app
    app: recommandations
spec:
  containers:
    - name: recommandations
      image: recommandations:latest
      envFrom:
        - configMapRef:
            name: postgres-config

Ang application ay Python at nagsisimula nang mas mabilis. Nagtatrabaho ito sa pag-connect sa PostgreSQL database. Malamang na, ang database ay hindi nagsisimula ng initialization, kaya ang koneksyon ay hindi magsisimula, at Kubernetes reboot ang pod.

Dapat nating gawin ito sa isanginitContainerAng isang container ay:

apiVersion: v1
kind: Pod
metadata:
  labels:
    type: app
    app: recommandations
spec:
  initContainers:
    - name: wait-for-postgres
      image: atkrad/wait4x:3.1
      command:
        - wait4x
        - postgresql
        - postgres://$(DATABASE_URL)?sslmode=disable
      envFrom:
        - configMapRef:
            name: postgres-config
  containers:
    - name: recommandations
      image: recommandations:latest
      envFrom:
        - configMapRef:
            name: postgres-config

Sa mga sumusunod na ito, anginitContainerHuwag i-share ang database kapag nag-akcept ang mga koneksyon. pagkatapos ay i-share ang databaserecommandationsang container ay maaaring magsisimula. Kubernetes ay hindi kailangang magsisimula angPodAs in the previous setup! Ito ay naglalaman ng mas mababang mga log at posibleng mas mababang alerts.

Kapag ang pagbabago ay obligasyon

Ang ibig sabihin naman ng non-repeating, walang numero o magkakatabing numero na nauulit ng infinite number of times.

sa loob
• Ang pipeline ay gumagamit ng isang manifesto sa Kubernetes side
sa loob
• Sa susunod na step, ito ay gumagana ang test
sa loob
• Kung ang pagsusuri ay nagsimula bago ang application ay nabasa, ito ay nangangahulugan.
sa loob

Kailangan mong maghintay hanggang sa backend ay ready bago kami test.wait4xupang maghintay para saPodPara sa pagkuha ng mga request bago kami nagsimula ng mga test:

      - name: Wait until the application has started
        uses: addnab/docker-run-action@v3                                       #1
        with:
          image: atkrad/wait4x:latest
          run: wait4x http ${{ env.BASE_URL }}/health --expect-status-code 200  #2

sa loob
1. Ang GitHub Action ay nagbibigay-daan sa pagpapatakbo ng isang container. I could have downloaded the Go binary instead.
sa loob
2. Panatilihin ang /health endpoint upang ibalik ang isang 200 response code.
sa loob

Konklusyon

Ang Kubernetes start-up probes ay isang mahusay na paraan upang maiwasan ang mga unnecessary reboot kapag nagsimula ang mga serbisyo na depende sa iba. Ang alternatibo ay isang external waiting tool na naka-configure sa isanginitContainerangwait4xIto ay isang tool na maaaring gamitin sa iba pang mga konteksto. Ito ngayon ay bahagi ng aking toolbelt.

To go further:

sa loob
• sa pamamagitan ng 4x
sa loob
• Kaya kailangan mong maghintay para sa ilang mga resources Kubernetes?
sa loob

Nai-publish sa A Java Geek sa Abril 20, 2025