Kung Bakit Pinagsamang Sistema ng Docker for Production Deployments

Ang modernong imprastraktura ay nangangailangan na ang mga serbisyong containerized ay makaligtas sa hindi inaasahang mga reboot, mga kabiguan sa hardware, o mga update ng pakete. Habang ang Docker ay nagbibigay ng mga patakarang retart (), ang mga patakarang ito ay gumagana lamang habang tumatakbo ang Docker daemon. Systemd – ang sistemang init na ginagamit ng Ubuntu, Debian, Fedora, CentOS, at ang karamihan sa mga modernong Linux distribusyon – ay kumukuha pa nito sa pamamagitan ng pangangasiwa ng lifecle ng Docker dack mismo bago pa man ang mga akto ay maging akto: Kabilang sa mga akto ng sistemang akt.

  • Tiyak na utos sa simula sa pamamagitan ng mga tagubilin sa dependency (hal.g., pagkatapos ng network.target, kasunod ng daong.service)
  • Pagkalbo sa pagtotroso sa pamamagitan ng , ginagawang tuwid ang pag - aalis ng mga bala
  • Mahusay na-guined control sa mga limitasyon ng yaman (CPU, memorya, I/O) gamit ang systemed unit workscriptions
  • Awtomatikong relater sa kabiguan sa pamamagitan ng maaaring baguhing pagkaantala at biglang mga hangganan
  • Suporta sa socket stack at timed simulaup

Sa pamamagitan ng pagbabalot ng bawat lalagyang Docker sa isang systemd service file, ang mga koponan ng operasyon ay nakakakuha ng isang hindi nagbabagong interface para sa pagsisimula, paghinto, at pagsubaybay ng mga lalagyan, pagbabawas ng pagtitiwala sa mga ad-hoc script at manufact intervention.

Paglikha ng Isang Sistemadong Serbisyo Para sa Isang Walang Asawang Maniniktik

Ang pamantayang pamamaraan ay ang pagsulat ng isang service unit file na tumatawag sa Docker na utos na tumakbo at ihinto ang lalagyan.

Hakbang 1: Isulat ang Service Unit File

Gumawa ng talaksang may pangalang . Gamitin ang sumusunod na template bilang pasimula:

[Unit]
Description=My Application Container
After=network-online.target docker.service
Wants=network-online.target
Requires=docker.service

[Service]
Restart=always
RestartSec=10
StartLimitBurst=3
ExecStartPre=-/usr/bin/docker kill myapp
ExecStartPre=-/usr/bin/docker rm myapp
ExecStart=/usr/bin/docker run --rm --name myapp \
 -e DB_HOST=10.0.1.50 \
 -e DB_PORT=5432 \
 -v /data/myapp:/app/data \
 -p 8080:8080 \
 myregistry/myapp:latest
ExecStop=/usr/bin/docker stop -t 10 myapp
ExecStopPost=-/usr/bin/docker rm myapp

[Install]
WantedBy=multi-user.target

Ekspektibong pagpapatupad ng mga pangunahing tagubilin:

  • [[ – tinitiyak na tumatakbo ang Docker daemon bago simulan ang lalagyan.
  • [[ – kung ihihinto ang Docker, titigil din ang serbisyong ito.
  • [[ – paglilinis ng anumang tirang lalagyan mula sa dating pagtakbo (] Ang panlapi ay nangangahulugan ng mga kabiguan dito ay non-fatal).
  • [[ – gamitin ang upang kusang tanggalin ang lalagyan kapag tumigil ito.
  • [ – Magandang paghinto sa lalagyan gamit ang timeout (10 segundo).
  • [ – muling i-reart ang lalagyan anuman ang kodigong labasan.
  • [ – maghintay ng 10 segundo bago muling mag-art.
  • [[ – limitahan ang mga restart hanggang 3 pagtatangka kada pagitan (default 10 segundo) upang maiwasan ang mga restart loop.

Hakbang 2: Malugod na Tinanggap at Magsimulang Maglingkod

sudo systemctl daemon-reload
sudo systemctl enable myapp.service
sudo systemctl start myapp.service

Ang ay nagsasabi sa systemd na muling basahin ang mga service file. ay lumilikha ng scafficial kaya ang serbisyo ay nagsisimula sa boboch.

Paghawak sa Paglilingkod sa Pamamagitan ng mga Pamantayang Utos

Kapag tumatakbo na ang serbisyo, kinokontrol mo na ito gaya ng ibang serbisyo sa sistema:

  • [ ]
  • Huminto:
  • [[Talaksan: ]
  • [
  • MgaLog: (kasunod ng mga live na troso)

Pinasulong na mga Parisan ng Pagsasang - ayon

Kadalasan nang kailangan ang higit pa sa simpleng para makagawa ng mga produkto.

Pagpasa ng Kapaligiran

Ang mga hard-coding na lihim o configuration sa file ng serbisyo ay hindi inirerekomenda. Sa halip, gumamit ng hiwalay na talaksang pangkapaligiran:

[Service]
EnvironmentFile=-/etc/myapp/env.conf
ExecStart=/usr/bin/docker run --rm --name myapp \
 --env-file /etc/myapp/env.conf \
 myregistry/myapp:latest

Ang unlaping bago ang landas ay nangangahulugang ang serbisyo ay magsisimula kahit na ang file ay hindi umiiral (ginagamit sa panahon ng panimulang setup).

Pag - uusap - usap sa Network at sa mga Pagbubuklod sa Daungan

Para sa mga lalagyan na kailangang makipag-usap sa isa't isa sa iisang host, isaalang-alang ang paggamit o user-flusioned bridge networks. Halimbawa:

ExecStart=/usr/bin/docker run --rm --name web \
 --network=my-net \
 -p 443:443 \
 -v /etc/ssl/certs:/etc/ssl/certs:ro \
 myregistry/web:latest

Kung gumagamit ka ng isang sistema ng kaugalian, tiyaking umiiral ang network bago magsimula ang serbisyo.

ExecStartPre=/usr/bin/docker network create my-net

Inter-Container Dependensiya

Kapag ang isang lalagyan ay nangangailangan ng isa pang handa bago magsimula (hal.g., isang web app na naghihintay ng isang database), ang systemd ay maaaring magpatupad ng ordering. Gumawa ng ikalawang service file para sa database at pagkatapos:

[Unit]
Description=Web App Container
After=network-online.target docker.service mydb.service
BindsTo=mydb.service

Ikinakabit ang web appisons lifecycle sa database container – kung hihinto ang database, ang web app ay natitigil rin.

Pagsusuri at Pagkabasa

Ang mga tseke sa kalusugan ng mga Docker ay maaaring isama sa sistemang ginagamit upang maiwasan ang maagang pagkuha ng serbisyo. Gamitin ang isang iskrip na nagsurbey sa endpoint ng kalusugan:

ExecStartPost=/usr/local/bin/wait-for-health.sh http://localhost:8080/health 30

Ang script ay dapat lumabas 0 lamang kapag malusog ang lalagyan. Kapag ito ay nabigo, i-sistema ang pag-uuri sa yunit bilang bigo.

Mga Hangganan sa Pag - iingat sa Pamamagitan ng Sistema

Maaari mong pilitin ang isang containerifics CPU at memorya sa antas ng group na walang Dockerites na sariling mga bandila ng yaman. ito ay lalo nang kapaki - pakinabang kapag nagpapatakbo ng maraming container sa isang host:

[Service]
MemoryMax=512M
CPUQuota=50%

Ang mga setting na ito ay lumilikha ng isang mahirap na limitasyon na ipinatutupad ng systemd nang independiyente sa Docker.

Pag - aasikaso sa Maraming - Gamit: Systemd vs. Docker Compose

Para sa maliit na bilang ng mga lalagyan (e.g., 2-5), ang mga isahang systemd service file ay simple at kaya. Gayunpaman, kapag ang isang proyekto ay kinasasangkutan ng maraming mga interconnect services, Docker Composse ay nagiging mas maginhawa. Maaari pa rin ninyong gamitin ang systemd upang i-chest ang buong Docker Compose na salansan sa pamamagitan ng paglikha ng isang solong service unit na tumatawag . Halimbawa:

[Unit]
Description=My Application Stack
After=network-online.target docker.service
Requires=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/opt/myapp
ExecStart=/usr/local/bin/docker-compose up -d
ExecStop=/usr/local/bin/docker-compose down

[Install]
WantedBy=multi-user.target

Ang pamamaraang ito ay nagbibigay sa iyo ng kapayakan ng Compose para sa pagbibigay ng kahulugan sa mga serbisyong sinamahan ng mga operasyong lifecycle.] Ang ay nagpapanatili sa yunit sa isang estadong ⁇ active ⁇ t ⁇ hanggang [[[[[[39]].

Anong paraan ang dapat mong piliin?

  • Individual systemd services – pinakamahusay para sa mga aplikasyong pang-agham, serbisyo na may mahigpit na simulap-up na pagsasaayos, o kapag kailangan mo ng per-container na mga limitasyong mapagkukunan.
  • Doccker Compose na may systemd – tamang-tama para sa mga salansan ng microservice kung saan ang mga dependensiya ay pinangangasiwaan sa internasyunal ng Compose, at nais mo ng isang yunit upang pangasiwaan ang buong grupo.

Problema sa Pag - unlad ng Karaniwang mga Isyu

Kahit maingat ka nang mag - set ng mga problema, madalas na may mga patibong sa ibaba at solusyon.

Bigo ang Paglilingkod sa pamamagitan ng ⁇ Cannot na nakikipag-ugnayan sa Docker daemoni

Karaniwang nangangahulugan ito ng serbisyong nagsisimula bago pa handa ang Docker saket. Ensurure Ang iyong yunit ay naglalaman at .Tanya din ang Docker daemon ay may kakayahang: .

Mga Restaurant na Naglalaman ng mga Pahinga sa Isang Loop

Kung ang lalagyan ay lalabas agad, i-sistema ang muling pag-arte nito ayon at . silipin ang mga troso ng container na may . Pagdami (e.g., 30 segundo) at itakda upang maiwasan ang isang abalang presilya.

Ang Paglilingkod ay Hindi Humihinto Nang Malinis

Maaaring hindi maayos ang pag-alis ng lalagyan.[T:49] Ginagamit ang tamang pangalan ng lalagyan. Gamitin upang ma-pwersang tanggalin ang lalagyan kung hindi natuloy ang paghinto.

Hindi Napasan ang mga Kabuktutan sa Kapaligiran

Kung gumagamit ka , pagtibayin ang umiiral na file at mabasa ito ng root. Iwasan ang pagsipi ng mga isyu – systemd strips quotes from variable values. Para sa lihim na iniksiyon, isaalang-alang gamit ang systemd encluentations o isang dedikadong secret manager.

Mga Pag - aasikaso sa Katiwasayan

Ang tumatakbong mga lalagyan ng Docker sa pamamagitan ng sistema ay nagbabangon ng ilang mga dakong panseguridad:

  • Laging patakbuhin ang serbisyong systemd bilang isang non-root user kung maaari (gamitin ang at na mga instruksiyon, ngunit tiyakin na ang gumagamit ay may access sa Docker saket o tumatakbo sa walang ugat na mode).
  • Iwasang gumamit sa mga yunit na may sistema maliban sa lubusang kinakailangan.
  • Gumamit ng mga read-lamang na mga pambatong () kailanma't hindi kailangang sulatan ng lalagyan ang punong-abala.
  • Ang Leverage systemditriks at upang tumigas ang yunit laban sa mga pagtakas.
[Service]
ProtectSystem=strict
ReadWritePaths=/var/log/myapp
PrivateTmp=true
User=myappuser

Mga Yaman sa Labas

Para sa higit pang pagbasa, tingnan ang opisyal na mga reperensiyang ito:

Pagsasaayos

Ang integrateng systemd na may mga docker container ay nagbibigay sa iyo ng isang matipuno at awtomatikong simulap na mekanismo na walang - pagbabagong nag - uugnay sa iba pang bahagi ng iyong Linux system. Sa pamamagitan ng pagsulat ng mga file na mahusay ang pagkakagawa, makokontrol mo ang startup order, mapangangasiwaan ang mga dependensiya, maglalagay ng limitasyon sa pag - aari, at maomonitor ang mga troso na ginagamit ang iyong pangkat sa operasyon.

Paandarin ang simpleng unit file, subuking mabuti, saka isalansan ang mga ito sa makabagong mga opsyon gaya ng mga file sa kapaligiran, pagsusuri sa kalusugan, at seguridad. Sa ganitong paraan, ang mga lalagyan ng iyong Docker ay makaliligtas sa mga reboot, banggaan, at pagbabago nang walang manu - manong interbensiyon, anupat hindi na makatutok ang iyong pangkat sa mga aplikasyon sa pagtatayo.