🥇ការដាក់ពង្រាយពណ៌ខៀវបៃតងនៅប្រាក់ឈ្នួលអប្បបរមា

នៅក្នុងអត្ថបទនេះយើងប្រើ bash, ssh, docker и nginx យើងនឹងរៀបចំប្លង់កម្មវិធីបណ្ដាញដែលគ្មានថ្នេរ។ ការដាក់ពង្រាយពណ៌ខៀវបៃតង គឺជាបច្ចេកទេសដែលអនុញ្ញាតឱ្យអ្នកធ្វើបច្ចុប្បន្នភាពកម្មវិធីភ្លាមៗដោយមិនបដិសេធសំណើតែមួយ។ វាគឺជាយុទ្ធសាស្រ្តមួយក្នុងចំនោមយុទ្ធសាស្ត្រដាក់ឱ្យដំណើរការគ្មានពេលទំនេរ ហើយស័ក្តិសមបំផុតសម្រាប់កម្មវិធីដែលមានឧទាហរណ៍មួយ ប៉ុន្តែសមត្ថភាពក្នុងការផ្ទុកវត្ថុទីពីរដែលត្រៀមរួចជាស្រេចដើម្បីដំណើរការនៅក្បែរនោះ។

ចូរនិយាយថាអ្នកមានកម្មវិធីបណ្តាញដែលអតិថិជនជាច្រើនកំពុងធ្វើការយ៉ាងសកម្ម ហើយវាពិតជាគ្មានផ្លូវសម្រាប់វាដេកពីរបីវិនាទីនោះទេ។ ហើយអ្នកពិតជាត្រូវដាក់ចេញការអាប់ដេតបណ្ណាល័យ ការជួសជុលបញ្ហា ឬមុខងារពិសេសថ្មី។ ក្នុងស្ថានភាពធម្មតា អ្នកនឹងត្រូវបញ្ឈប់កម្មវិធី ជំនួសវា ហើយចាប់ផ្តើមវាម្តងទៀត។ ក្នុងករណី docker ដំបូងអ្នកអាចជំនួសវា បន្ទាប់មកចាប់ផ្តើមវាឡើងវិញ ប៉ុន្តែវានឹងនៅតែមានរយៈពេលដែលសំណើទៅកាន់កម្មវិធីនឹងមិនដំណើរការទេ ព្រោះជាធម្មតាកម្មវិធីត្រូវចំណាយពេលខ្លះដើម្បីដំណើរការដំបូង។ ចុះបើវាចាប់ផ្ដើម ប៉ុន្តែវាមិនអាចប្រើបាន? នេះជាបញ្ហា សូមដោះស្រាយវាដោយមធ្យោបាយតិចតួចបំផុត និងឆើតឆាយតាមដែលអាចធ្វើទៅបាន។

ការបដិសេធ៖ អត្ថបទភាគច្រើនត្រូវបានបង្ហាញជាទម្រង់ពិសោធន៍ - ជាទម្រង់នៃការថតសម័យកុងសូល។ សង្ឃឹមថានេះនឹងមិនពិបាកយល់ពេកទេ ហើយលេខកូដនឹងចងក្រងដោយខ្លួនវាគ្រប់គ្រាន់។ សម្រាប់បរិយាកាស សូមស្រមៃថា ទាំងនេះមិនមែនគ្រាន់តែជាអត្ថបទកូដប៉ុណ្ណោះទេ ប៉ុន្តែជាក្រដាសពីទូរលេខ "ដែក"។

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍ដែលពិបាកសម្រាប់ Google ដោយគ្រាន់តែអានកូដត្រូវបានពិពណ៌នានៅដើមផ្នែកនីមួយៗ។ ប្រសិនបើមានអ្វីផ្សេងទៀតមិនច្បាស់លាស់, google វាហើយពិនិត្យមើលវាចេញ។ ពន្យល់សែល (ជាសំណាងល្អ វាដំណើរការម្តងទៀត ដោយសារតែការបិទទូរលេខ)។ ប្រសិនបើអ្នកមិនអាច Google អ្វីបានទេ សូមសួរនៅក្នុងមតិយោបល់។ ខ្ញុំនឹងរីករាយក្នុងការបន្ថែមទៅផ្នែកដែលត្រូវគ្នា "បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍" ។

តោះចាប់ផ្តើម។

$ mkdir blue-green-deployment && cd $_

RЎRμSЂRІRёSЃ

ចូរយើងបង្កើតសេវាកម្មពិសោធន៍ ហើយដាក់វានៅក្នុងធុងមួយ។

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

cat << EOF > file-name (ឯកសារនៅទីនេះ + ការបញ្ជូនបន្ត I/O) គឺជាវិធីមួយដើម្បីបង្កើតឯកសារពហុបន្ទាត់ដោយប្រើពាក្យបញ្ជាមួយ។ អ្វីគ្រប់យ៉ាងដែល bash អានពី /dev/stdin បន្ទាប់ពីបន្ទាត់នេះ និងមុនបន្ទាត់ EOF នឹងត្រូវបានកត់ត្រានៅក្នុង file-name.
wget -qO- URL (ពន្យល់សែល) — បញ្ចេញឯកសារដែលបានទទួលតាមរយៈ HTTP ទៅ /dev/stdout (អាណាឡូក curl URL).

បោះពុម្ព

ជាពិសេស ខ្ញុំទម្លាយព័ត៌មានសង្ខេប ដើម្បីបើកការបន្លិចសម្រាប់ Python ។ នៅចុងបញ្ចប់នឹងមានបំណែកមួយទៀតដូចនេះ។ ពិចារណាថានៅកន្លែងទាំងនេះ ក្រដាសត្រូវបានកាត់ដើម្បីផ្ញើទៅផ្នែកបន្លិច (ដែលលេខកូដត្រូវបានលាបពណ៌ដោយដៃជាមួយឧបករណ៍បន្លិច) ហើយបន្ទាប់មកបំណែកទាំងនេះត្រូវបានស្អិតជាប់។

$ cat << EOF > uptimer.py

from http.server import BaseHTTPRequestHandler, HTTPServer
from time import monotonic

app_version = 1
app_name = f'Uptimer v{app_version}.0'
loading_seconds = 15 - app_version * 5

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/':
            try:
                t = monotonic() - server_start
                if t < loading_seconds:
                    self.send_error(503)
                else:
                    self.send_response(200)
                    self.send_header('Content-Type', 'text/html')
                    self.end_headers()
                    response = f'<h2>{app_name} is running for {t:3.1f} seconds.</h2>n'
                    self.wfile.write(response.encode('utf-8'))
            except Exception:
                self.send_error(500)
        else:
            self.send_error(404)

httpd = HTTPServer(('', 8080), Handler)
server_start = monotonic()
print(f'{app_name} (loads in {loading_seconds} sec.) started.')
httpd.serve_forever()

EOF

$ cat << EOF > Dockerfile
FROM python:alpine
EXPOSE 8080
COPY uptimer.py app.py
CMD [ "python", "-u", "./app.py" ]
EOF

$ docker build --tag uptimer .
Sending build context to Docker daemon  39.42kB
Step 1/4 : FROM python:alpine
 ---> 8ecf5a48c789
Step 2/4 : EXPOSE 8080
 ---> Using cache
 ---> cf92d174c9d3
Step 3/4 : COPY uptimer.py app.py
 ---> a7fbb33d6b7e
Step 4/4 : CMD [ "python", "-u", "./app.py" ]
 ---> Running in 1906b4bd9fdf
Removing intermediate container 1906b4bd9fdf
 ---> c1655b996fe8
Successfully built c1655b996fe8
Successfully tagged uptimer:latest

$ docker run --rm --detach --name uptimer --publish 8080:8080 uptimer
8f88c944b8bf78974a5727070a94c76aa0b9bb2b3ecf6324b784e782614b2fbf

$ docker ps
CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
8f88c944b8bf        uptimer             "python -u ./app.py"   3 seconds ago       Up 5 seconds        0.0.0.0:8080->8080/tcp   uptimer

$ docker logs uptimer
Uptimer v1.0 (loads in 10 sec.) started.

$ wget -qSO- http://localhost:8080
  HTTP/1.0 503 Service Unavailable
  Server: BaseHTTP/0.6 Python/3.8.3
  Date: Sat, 22 Aug 2020 19:52:40 GMT
  Connection: close
  Content-Type: text/html;charset=utf-8
  Content-Length: 484

$ wget -qSO- http://localhost:8080
  HTTP/1.0 200 OK
  Server: BaseHTTP/0.6 Python/3.8.3
  Date: Sat, 22 Aug 2020 19:52:45 GMT
  Content-Type: text/html
<h2>Uptimer v1.0 is running for 15.4 seconds.</h2>

$ docker rm --force uptimer
uptimer

ប្រូកស៊ីបញ្ច្រាស

ដើម្បីឱ្យកម្មវិធីរបស់យើងអាចផ្លាស់ប្តូរដោយមិនមាននរណាកត់សម្គាល់ វាចាំបាច់ថាមានអង្គភាពផ្សេងទៀតនៅពីមុខវាដែលនឹងលាក់ការជំនួសរបស់វា។ វាអាចជា web server nginx в របៀបប្រូកស៊ីបញ្ច្រាស. ប្រូកស៊ីបញ្ច្រាសត្រូវបានបង្កើតឡើងរវាងអតិថិជន និងកម្មវិធី។ វាទទួលយកសំណើពីអតិថិជន និងបញ្ជូនពួកគេទៅកាន់កម្មវិធី និងបញ្ជូនការឆ្លើយតបរបស់កម្មវិធីទៅអតិថិជន។

កម្មវិធី និងប្រូកស៊ីបញ្ច្រាសអាចត្រូវបានភ្ជាប់នៅខាងក្នុង docker ដោយប្រើ បណ្តាញ docker. ដូច្នេះ កុងតឺន័រដែលមានកម្មវិធីមិនចាំបាច់បញ្ជូនច្រកនៅលើប្រព័ន្ធម៉ាស៊ីនទេ វាអនុញ្ញាតឱ្យកម្មវិធីដាច់ឆ្ងាយពីការគំរាមកំហែងពីខាងក្រៅ។

ប្រសិនបើប្រូកស៊ីបញ្ច្រាសរស់នៅលើម៉ាស៊ីនផ្សេងទៀត អ្នកនឹងត្រូវបោះបង់ចោលបណ្តាញ docker ហើយភ្ជាប់កម្មវិធីទៅប្រូកស៊ីបញ្ច្រាសតាមរយៈបណ្តាញម៉ាស៊ីន ដោយបញ្ជូនបន្តច្រក។ កម្មវិធី ប៉ារ៉ាម៉ែត្រ --publishដូចពេលចាប់ផ្តើមដំបូង និងដូចគ្នានឹងប្រូកស៊ីបញ្ច្រាសដែរ។

យើងនឹងដំណើរការប្រូកស៊ីបញ្ច្រាសនៅលើច្រក 80 ពីព្រោះនេះពិតជាអង្គភាពដែលគួរស្តាប់បណ្តាញខាងក្រៅ។ ប្រសិនបើច្រក 80 ជាប់រវល់នៅលើម៉ាស៊ីនសាកល្បងរបស់អ្នក សូមប្តូរប៉ារ៉ាម៉ែត្រ --publish 80:80 នៅលើ --publish ANY_FREE_PORT:80.

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

"នៅក្នុងបណ្តាញ Docker ដែលបង្កើតដោយអ្នកប្រើប្រាស់ អ្នកអាចទំនាក់ទំនងជាមួយកុងតឺន័រមិនត្រឹមតែតាមរយៈអាសយដ្ឋាន IP ប៉ុណ្ណោះទេ។ ឈ្មោះកុងតឺន័រក៏ត្រូវបានដោះស្រាយទៅក្នុងអាសយដ្ឋាន IP របស់វាផងដែរ"(អត្ថបទ "ការភ្ជាប់បណ្តាញជាមួយធុងដាច់ដោយឡែក" ផ្នែក "ប្រើបណ្តាញស្ពានកំណត់ដោយអ្នកប្រើប្រាស់"ចំណុចទី 5 នៃកូដ docker) ។

បោះពុម្ព

$ docker network create web-gateway
5dba128fb3b255b02ac012ded1906b7b4970b728fb7db3dbbeccc9a77a5dd7bd

$ docker run --detach --rm --name uptimer --network web-gateway uptimer
a1105f1b583dead9415e99864718cc807cc1db1c763870f40ea38bc026e2d67f

$ docker run --rm --network web-gateway alpine wget -qO- http://uptimer:8080
<h2>Uptimer v1.0 is running for 11.5 seconds.</h2>

$ docker run --detach --publish 80:80 --network web-gateway --name reverse-proxy nginx:alpine
80695a822c19051260c66bf60605dcb4ea66802c754037704968bc42527bf120

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                NAMES
80695a822c19        nginx:alpine        "/docker-entrypoint.…"   27 seconds ago       Up 25 seconds       0.0.0.0:80->80/tcp   reverse-proxy
a1105f1b583d        uptimer             "python -u ./app.py"     About a minute ago   Up About a minute   8080/tcp             uptimer

$ cat << EOF > uptimer.conf
server {
    listen 80;
    location / {
        proxy_pass http://uptimer:8080;
    }
}
EOF

$ docker cp ./uptimer.conf reverse-proxy:/etc/nginx/conf.d/default.conf

$ docker exec reverse-proxy nginx -s reload
2020/06/23 20:51:03 [notice] 31#31: signal process started

$ wget -qSO- http://localhost
  HTTP/1.1 200 OK
  Server: nginx/1.19.0
  Date: Sat, 22 Aug 2020 19:56:24 GMT
  Content-Type: text/html
  Transfer-Encoding: chunked
  Connection: keep-alive
<h2>Uptimer v1.0 is running for 104.1 seconds.</h2>

ការដាក់ពង្រាយគ្មានថ្នេរ

សូមដាក់ចេញកំណែថ្មីនៃកម្មវិធី (ជាមួយការជំរុញដំណើរការចាប់ផ្តើមពីរដង) ហើយព្យាយាមដាក់ឱ្យដំណើរការវាយ៉ាងរលូន។

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

echo 'my text' | docker exec -i my-container sh -c 'cat > /my-file.txt' - សរសេរអត្ថបទ my text ទៅកាន់ឯកសារ /my-file.txt នៅខាងក្នុងធុង my-container.
cat > /my-file.txt - សរសេរមាតិកានៃការបញ្ចូលស្តង់ដារទៅឯកសារ /dev/stdin.

បោះពុម្ព

$ sed -i "s/app_version = 1/app_version = 2/" uptimer.py

$ docker build --tag uptimer .
Sending build context to Docker daemon  39.94kB
Step 1/4 : FROM python:alpine
 ---> 8ecf5a48c789
Step 2/4 : EXPOSE 8080
 ---> Using cache
 ---> cf92d174c9d3
Step 3/4 : COPY uptimer.py app.py
 ---> 3eca6a51cb2d
Step 4/4 : CMD [ "python", "-u", "./app.py" ]
 ---> Running in 8f13c6d3d9e7
Removing intermediate container 8f13c6d3d9e7
 ---> 1d56897841ec
Successfully built 1d56897841ec
Successfully tagged uptimer:latest

$ docker run --detach --rm --name uptimer_BLUE --network web-gateway uptimer
96932d4ca97a25b1b42d1b5f0ede993b43f95fac3c064262c5c527e16c119e02

$ docker logs uptimer_BLUE
Uptimer v2.0 (loads in 5 sec.) started.

$ docker run --rm --network web-gateway alpine wget -qO- http://uptimer_BLUE:8080
<h2>Uptimer v2.0 is running for 23.9 seconds.</h2>

$ sed s/uptimer/uptimer_BLUE/ uptimer.conf | docker exec --interactive reverse-proxy sh -c 'cat > /etc/nginx/conf.d/default.conf'

$ docker exec reverse-proxy cat /etc/nginx/conf.d/default.conf
server {
    listen 80;
    location / {
        proxy_pass http://uptimer_BLUE:8080;
    }
}

$ docker exec reverse-proxy nginx -s reload
2020/06/25 21:22:23 [notice] 68#68: signal process started

$ wget -qO- http://localhost
<h2>Uptimer v2.0 is running for 63.4 seconds.</h2>

$ docker rm -f uptimer
uptimer

$ wget -qO- http://localhost
<h2>Uptimer v2.0 is running for 84.8 seconds.</h2>

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                NAMES
96932d4ca97a        uptimer             "python -u ./app.py"     About a minute ago   Up About a minute   8080/tcp             uptimer_BLUE
80695a822c19        nginx:alpine        "/docker-entrypoint.…"   8 minutes ago        Up 8 minutes        0.0.0.0:80->80/tcp   reverse-proxy

នៅដំណាក់កាលនេះ រូបភាពត្រូវបានបង្កើតឡើងដោយផ្ទាល់នៅលើម៉ាស៊ីនមេ ដែលតម្រូវឱ្យប្រភពកម្មវិធីនៅទីនោះ ហើយផ្ទុកម៉ាស៊ីនមេជាមួយនឹងការងារដែលមិនចាំបាច់។ ជំហានបន្ទាប់គឺត្រូវបែងចែកការផ្គុំរូបភាពទៅម៉ាស៊ីនដាច់ដោយឡែក (ឧទាហរណ៍ទៅប្រព័ន្ធ CI) ហើយបន្ទាប់មកផ្ទេរវាទៅម៉ាស៊ីនមេ។

ការផ្ទេររូបភាព

ជាអកុសល វាមិនសមហេតុផលក្នុងការផ្ទេររូបភាពពី localhost ទៅ localhost ទេ ដូច្នេះផ្នែកនេះអាចរុករកបានលុះត្រាតែអ្នកមានម៉ាស៊ីនពីរជាមួយ Docker នៅនឹងដៃ។ យ៉ាងហោចណាស់វាមើលទៅដូចនេះ៖

$ ssh production-server docker image ls
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE

$ docker image save uptimer | ssh production-server 'docker image load'
Loaded image: uptimer:latest

$ ssh production-server docker image ls
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
uptimer             latest              1d56897841ec        5 minutes ago       78.9MB

ក្រុមការងារ docker save រក្សាទុកទិន្នន័យរូបភាពនៅក្នុងប័ណ្ណសារ .tar មានន័យថាវាមានទម្ងន់ប្រហែល 1.5 ដងច្រើនជាងទម្ងន់របស់វាក្នុងទម្រង់ដែលបានបង្ហាប់។ ដូច្នេះសូមអ្រងួនក្នុងនាមនៃការសន្សំពេលវេលា និងចរាចរណ៍៖

$ docker image save uptimer | gzip | ssh production-server 'zcat | docker image load'
Loaded image: uptimer:latest

អ្នកក៏អាចត្រួតពិនិត្យដំណើរការទាញយក (ទោះបីជាវាទាមទារឧបករណ៍ប្រើប្រាស់ភាគីទីបីក៏ដោយ)៖

$ docker image save uptimer | gzip | pv | ssh production-server 'zcat | docker image load'
25,7MiB 0:01:01 [ 425KiB/s] [                   <=>    ]
Loaded image: uptimer:latest

គន្លឹះ៖ ប្រសិនបើអ្នកត្រូវការប៉ារ៉ាម៉ែត្រជាច្រើនដើម្បីភ្ជាប់ទៅម៉ាស៊ីនមេតាមរយៈ SSH អ្នកប្រហែលជាមិនប្រើឯកសារទេ ~/.ssh/config.

ផ្ទេររូបភាពតាមរយៈ docker image save/load - នេះគឺជាវិធីសាស្រ្តតិចតួចបំផុត ប៉ុន្តែមិនមែនតែមួយទេ។ មានផ្សេងទៀត៖

ការចុះបញ្ជីកុងតឺន័រ (ស្តង់ដារឧស្សាហកម្ម) ។
ភ្ជាប់ទៅម៉ាស៊ីនមេ docker daemon ពីម៉ាស៊ីនផ្សេងទៀត៖
1. បរិស្ថានប្រែប្រួល DOCKER_HOST.
2. ជម្រើសបន្ទាត់ពាក្យបញ្ជា -H ឬ --host ឧបករណ៍ docker-compose.
3. docker context

វិធីសាស្រ្តទីពីរ (ជាមួយនឹងជម្រើសបីសម្រាប់ការអនុវត្តរបស់វា) ត្រូវបានពិពណ៌នាយ៉ាងល្អនៅក្នុងអត្ថបទ របៀបដាក់ពង្រាយនៅលើ Docker hosts ពីចម្ងាយជាមួយ docker-compose.

`deploy.sh`

ឥឡូវនេះ ចូរយើងប្រមូលអ្វីគ្រប់យ៉ាងដែលយើងបានធ្វើដោយដៃទៅក្នុងស្គ្រីបតែមួយ។ ចូរចាប់ផ្តើមជាមួយនឹងមុខងារកម្រិតកំពូល ហើយបន្ទាប់មកមើលមុខងារផ្សេងទៀតដែលបានប្រើនៅក្នុងវា។

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

${parameter?err_msg} - មួយនៃអក្ខរាវិរុទ្ធវេទមន្ត bash (aka ការជំនួសប៉ារ៉ាម៉ែត្រ) ប្រសិនបើ parameter មិនបានបញ្ជាក់, ទិន្នផល err_msg ហើយចេញដោយលេខកូដ 1 ។
docker --log-driver journald - តាមលំនាំដើម កម្មវិធីបញ្ជាការកត់ត្រា docker គឺជាឯកសារអត្ថបទដោយគ្មានការបង្វិលណាមួយឡើយ។ ជាមួយនឹងវិធីសាស្រ្តនេះ កំណត់ហេតុអាចបំពេញថាសទាំងមូលបានយ៉ាងឆាប់រហ័ស ដូច្នេះសម្រាប់បរិយាកាសផលិតកម្ម ចាំបាច់ត្រូវផ្លាស់ប្តូរកម្មវិធីបញ្ជាឱ្យកាន់តែឆ្លាតវៃ។

ស្គ្រីបដាក់ឱ្យប្រើប្រាស់

deploy() {
    local usage_msg="Usage: ${FUNCNAME[0]} image_name"
    local image_name=${1?$usage_msg}

    ensure-reverse-proxy || return 2
    if get-active-slot $image_name
    then
        local OLD=${image_name}_BLUE
        local new_slot=GREEN
    else
        local OLD=${image_name}_GREEN
        local new_slot=BLUE
    fi
    local NEW=${image_name}_${new_slot}
    echo "Deploying '$NEW' in place of '$OLD'..."
    docker run 
        --detach 
        --restart always 
        --log-driver journald 
        --name $NEW 
        --network web-gateway 
        $image_name || return 3
    echo "Container started. Checking health..."
    for i in {1..20}
    do
        sleep 1
        if get-service-status $image_name $new_slot
        then
            echo "New '$NEW' service seems OK. Switching heads..."
            sleep 2  # Ensure service is ready
            set-active-slot $image_name $new_slot || return 4
            echo "'$NEW' service is live!"
            sleep 2  # Ensure all requests were processed
            echo "Killing '$OLD'..."
            docker rm -f $OLD
            docker image prune -f
            echo "Deployment successful!"
            return 0
        fi
        echo "New '$NEW' service is not ready yet. Waiting ($i)..."
    done
    echo "New '$NEW' service did not raise, killing it. Failed to deploy T_T"
    docker rm -f $NEW
    return 5
}

លក្ខណៈពិសេសដែលបានប្រើ៖

ensure-reverse-proxy - ត្រូវប្រាកដថាប្រូកស៊ីបញ្ច្រាសកំពុងដំណើរការ (មានប្រយោជន៍សម្រាប់ការដាក់ពង្រាយដំបូង)
get-active-slot service_name - កំណត់ថាតើរន្ធដោតមួយណាដែលសកម្មសម្រាប់សេវាកម្មដែលបានផ្តល់ឱ្យ (BLUE ឬ GREEN)
get-service-status service_name deployment_slot - កំណត់ថាតើសេវាកម្មនេះរួចរាល់ដើម្បីដំណើរការសំណើចូលឬអត់
set-active-slot service_name deployment_slot - ផ្លាស់ប្តូរការកំណត់រចនាសម្ព័ន្ធ nginx នៅក្នុងធុងប្រូកស៊ីបញ្ច្រាស

នៅក្នុងលំដាប់:

ensure-reverse-proxy() {
    is-container-up reverse-proxy && return 0
    echo "Deploying reverse-proxy..."
    docker network create web-gateway
    docker run 
        --detach 
        --restart always 
        --log-driver journald 
        --name reverse-proxy 
        --network web-gateway 
        --publish 80:80 
        nginx:alpine || return 1
    docker exec --interactive reverse-proxy sh -c "> /etc/nginx/conf.d/default.conf"
    docker exec reverse-proxy nginx -s reload
}

is-container-up() {
    local container=${1?"Usage: ${FUNCNAME[0]} container_name"}

    [ -n "$(docker ps -f name=${container} -q)" ]
    return $?
}

get-active-slot() {
    local service=${1?"Usage: ${FUNCNAME[0]} service_name"}

    if is-container-up ${service}_BLUE && is-container-up ${service}_GREEN; then
        echo "Collision detected! Stopping ${service}_GREEN..."
        docker rm -f ${service}_GREEN
        return 0  # BLUE
    fi
    if is-container-up ${service}_BLUE && ! is-container-up ${service}_GREEN; then
        return 0  # BLUE
    fi
    if ! is-container-up ${service}_BLUE; then
        return 1  # GREEN
    fi
}

get-service-status() {
    local usage_msg="Usage: ${FUNCNAME[0]} service_name deployment_slot"
    local service=${1?usage_msg}
    local slot=${2?$usage_msg}

    case $service in
        # Add specific healthcheck paths for your services here
        *) local health_check_port_path=":8080/" ;;
    esac
    local health_check_address="http://${service}_${slot}${health_check_port_path}"
    echo "Requesting '$health_check_address' within the 'web-gateway' docker network:"
    docker run --rm --network web-gateway alpine 
        wget --timeout=1 --quiet --server-response $health_check_address
    return $?
}

set-active-slot() {
    local usage_msg="Usage: ${FUNCNAME[0]} service_name deployment_slot"
    local service=${1?$usage_msg}
    local slot=${2?$usage_msg}
    [ "$slot" == BLUE ] || [ "$slot" == GREEN ] || return 1

    get-nginx-config $service $slot | docker exec --interactive reverse-proxy sh -c "cat > /etc/nginx/conf.d/$service.conf"
    docker exec reverse-proxy nginx -t || return 2
    docker exec reverse-proxy nginx -s reload
}

មុខងារ get-active-slot ទាមទារការពន្យល់តិចតួច៖

ហេតុអ្វីបានជាវាត្រឡប់លេខ ហើយមិនចេញខ្សែ?

ទោះយ៉ាងណាក៏ដោយ នៅក្នុងមុខងារហៅទូរសព្ទ យើងពិនិត្យមើលលទ្ធផលនៃការងាររបស់វា ហើយការពិនិត្យមើលលេខកូដចេញដោយប្រើ bash គឺងាយស្រួលជាងការពិនិត្យមើលខ្សែអក្សរ។ លើសពីនេះទៀតការទទួលបានខ្សែពីវាគឺសាមញ្ញណាស់:
get-active-slot service && echo BLUE || echo GREEN.

តើលក្ខខណ្ឌបីពិតជាគ្រប់គ្រាន់ដើម្បីបែងចែករដ្ឋទាំងអស់មែនទេ?

សូម្បីតែពីរនឹងគ្រប់គ្រាន់ហើយ ចុងក្រោយគឺនៅទីនេះសម្រាប់ភាពពេញលេញ ដើម្បីកុំឱ្យសរសេរ else.

មានតែមុខងារដែលត្រឡប់ការកំណត់រចនាសម្ព័ន្ធ nginx ប៉ុណ្ណោះដែលមិនត្រូវបានកំណត់៖ get-nginx-config service_name deployment_slot. ដោយភាពស្រដៀងគ្នាជាមួយនឹងការពិនិត្យសុខភាព នៅទីនេះអ្នកអាចកំណត់ការកំណត់ណាមួយសម្រាប់សេវាកម្មណាមួយ។ នៃអ្វីដែលគួរឱ្យចាប់អារម្មណ៍ - តែប៉ុណ្ណោះ cat <<- EOFដែលអនុញ្ញាតឱ្យអ្នកលុបផ្ទាំងទាំងអស់នៅដើម។ ពិតហើយ តម្លៃនៃការធ្វើទ្រង់ទ្រាយល្អគឺជាផ្ទាំងចម្រុះជាមួយចន្លោះ ដែលសព្វថ្ងៃនេះត្រូវបានចាត់ទុកថាជាទម្រង់អាក្រក់ណាស់។ ប៉ុន្តែផ្ទាំងកងកម្លាំង bash ហើយវាក៏ល្អផងដែរក្នុងការធ្វើទ្រង់ទ្រាយធម្មតានៅក្នុងការកំណត់រចនាសម្ព័ន្ធ nginx ។ សរុបមក ការលាយផ្ទាំងជាមួយដកឃ្លានៅទីនេះពិតជាហាក់ដូចជាដំណោះស្រាយដ៏ល្អបំផុតចេញពីអ្វីដែលអាក្រក់បំផុត។ ទោះជាយ៉ាងណាក៏ដោយ អ្នកនឹងមិនឃើញវានៅក្នុងផ្នែកខាងក្រោមទេ ចាប់តាំងពី Habr "ធ្វើវាបានល្អ" ដោយការផ្លាស់ប្តូរផ្ទាំងទាំងអស់ទៅជា 4 spaces និងធ្វើឱ្យ EOF មិនត្រឹមត្រូវ។ ហើយនៅទីនេះវាគួរឱ្យកត់សម្គាល់.

ដើម្បីកុំឱ្យក្រោកឡើងពីរដង ខ្ញុំនឹងប្រាប់អ្នកភ្លាមៗអំពី cat << 'EOF'ដែលនឹងជួបប្រទះនៅពេលក្រោយ។ ប្រសិនបើអ្នកសរសេរយ៉ាងសាមញ្ញ cat << EOFបន្ទាប់មកនៅខាងក្នុង heredoc ខ្សែអក្សរត្រូវបាន interpolated (អថេរត្រូវបានពង្រីក ($foo), ការហៅពាក្យបញ្ជា ($(bar)) ។ល។) ហើយប្រសិនបើអ្នកភ្ជាប់ចុងបញ្ចប់នៃឯកសារក្នុងសម្រង់តែមួយ នោះការបកស្រាយត្រូវបានបិទ ហើយនិមិត្តសញ្ញា $ ត្រូវបានបង្ហាញដូច។ អ្វីដែលអ្នកត្រូវការដើម្បីបញ្ចូលស្គ្រីបនៅខាងក្នុងស្គ្រីបផ្សេងទៀត។

get-nginx-config() {
    local usage_msg="Usage: ${FUNCNAME[0]} service_name deployment_slot"
    local service=${1?$usage_msg}
    local slot=${2?$usage_msg}
    [ "$slot" == BLUE ] || [ "$slot" == GREEN ] || return 1

    local container_name=${service}_${slot}
    case $service in
        # Add specific nginx configs for your services here
        *) nginx-config-simple-service $container_name:8080 ;;
    esac
}

nginx-config-simple-service() {
    local usage_msg="Usage: ${FUNCNAME[0]} proxy_pass"
    local proxy_pass=${1?$usage_msg}

cat << EOF
server {
    listen 80;
    location / {
        proxy_pass http://$proxy_pass;
    }
}
EOF
}

នេះគឺជាស្គ្រីបទាំងមូល។ ហើយដូច្នេះ gist ជាមួយស្គ្រីបនេះ។ សម្រាប់ការទាញយកតាមរយៈ wget ឬ curl ។

ដំណើរការស្គ្រីបដែលបានកំណត់ប៉ារ៉ាម៉ែត្រនៅលើម៉ាស៊ីនមេពីចម្ងាយ

វាដល់ពេលហើយដើម្បីគោះលើម៉ាស៊ីនមេគោលដៅ។ ពេលនេះ localhost សមរម្យណាស់៖

$ ssh-copy-id localhost
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
himura@localhost's password: 

Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'localhost'"
and check to make sure that only the key(s) you wanted were added.

យើងបានសរសេរស្គ្រីបដាក់ពង្រាយដែលទាញយករូបភាពដែលបានបង្កើតជាមុនទៅកាន់ម៉ាស៊ីនមេគោលដៅ ហើយជំនួសកន្លែងផ្ទុកសេវាកម្មយ៉ាងរលូន ប៉ុន្តែតើយើងអាចប្រតិបត្តិវាដោយរបៀបណានៅលើម៉ាស៊ីនពីចម្ងាយ? ស្គ្រីបមានអាគុយម៉ង់ ព្រោះវាមានលក្ខណៈជាសកល ហើយអាចប្រើប្រាស់សេវាកម្មជាច្រើនក្នុងពេលតែមួយក្រោមប្រូកស៊ីបញ្ច្រាសមួយ (អ្នកអាចប្រើ nginx configs ដើម្បីកំណត់ url មួយណាជាសេវាកម្មមួយណា)។ ស្គ្រីបមិនអាចរក្សាទុកនៅលើម៉ាស៊ីនមេបានទេ ព្រោះក្នុងករណីនេះ យើងនឹងមិនអាចអាប់ដេតវាដោយស្វ័យប្រវត្តិបានទេ (សម្រាប់គោលបំណងជួសជុលកំហុស និងបន្ថែមសេវាកម្មថ្មី) ហើយជាទូទៅ ស្ថានភាព = អាក្រក់។

ដំណោះស្រាយទី 1: នៅតែរក្សាទុកស្គ្រីបនៅលើម៉ាស៊ីនមេ ប៉ុន្តែចម្លងវារាល់ពេលឆ្លងកាត់ scp. បន្ទាប់មកភ្ជាប់តាមរយៈ ssh និងប្រតិបត្តិស្គ្រីបជាមួយនឹងអាគុយម៉ង់ចាំបាច់។

គុណវិបត្តិ:

សកម្មភាពពីរជំនួសឱ្យមួយ។
ប្រហែលជាមិនមានកន្លែងដែលអ្នកចម្លង ឬប្រហែលជាមិនមានសិទ្ធិចូលប្រើវា ឬស្គ្រីបអាចត្រូវបានប្រតិបត្តិនៅពេលជំនួស។
វាត្រូវបានណែនាំឱ្យសម្អាតបន្ទាប់ពីខ្លួនអ្នក (លុបស្គ្រីប) ។
សកម្មភាពបីរួចហើយ។

ដំណោះស្រាយ 2:

ទុកតែនិយមន័យមុខងារនៅក្នុងស្គ្រីប ហើយមិនដំណើរការអ្វីទាំងអស់។
ដោយមានជំនួយពី sed បន្ថែមមុខងារហៅទៅចុងបញ្ចប់
ផ្ញើវាទាំងអស់ដោយផ្ទាល់ទៅ shh តាមរយៈបំពង់ (|)

ប្រុស:

ពិតជាគ្មានរដ្ឋ
មិនមានធាតុ boilerplate
មានអារម្មណ៍ត្រជាក់

ចូរយើងធ្វើវាដោយគ្មាន Ansible ។ បាទ អ្វីៗត្រូវបានបង្កើតរួចហើយ។ បាទ កង់។ មកមើលថាតើម៉ូតូនេះមានលក្ខណៈសាមញ្ញ ឆើតឆាយ និងតូចប៉ុណ្ណា៖

$ cat << 'EOF' > deploy.sh

#!/bin/bash

usage_msg="Usage: $0 ssh_address local_image_tag"
ssh_address=${1?$usage_msg}
image_name=${2?$usage_msg}

echo "Connecting to '$ssh_address' via ssh to seamlessly deploy '$image_name'..."
( sed "$a deploy $image_name" | ssh -T $ssh_address ) << 'END_OF_SCRIPT'
deploy() {
    echo "Yay! The '${FUNCNAME[0]}' function is executing on '$(hostname)' with argument '$1'"
}
END_OF_SCRIPT

EOF

$ chmod +x deploy.sh

$ ./deploy.sh localhost magic-porridge-pot
Connecting to localhost...
Yay! The 'deploy' function is executing on 'hut' with argument 'magic-porridge-pot'

ទោះយ៉ាងណាក៏ដោយ យើងមិនអាចប្រាកដថាម៉ាស៊ីនពីចម្ងាយមាន bash គ្រប់គ្រាន់ទេ ដូច្នេះយើងនឹងបន្ថែមការត្រួតពិនិត្យតូចមួយនៅដើមដំបូង (នេះគឺជំនួសឱ្យ shellbang):

if [ "$SHELL" != "/bin/bash" ]
then
    echo "The '$SHELL' shell is not supported by 'deploy.sh'. Set a '/bin/bash' shell for '$USER@$HOSTNAME'."
    exit 1
fi

ហើយឥឡូវនេះវាជាការពិត៖

$ docker exec reverse-proxy rm /etc/nginx/conf.d/default.conf

$ wget -qO deploy.sh https://git.io/JUURc

$ chmod +x deploy.sh

$ ./deploy.sh localhost uptimer
Sending gzipped image 'uptimer' to 'localhost' via ssh...
Loaded image: uptimer:latest
Connecting to 'localhost' via ssh to seamlessly deploy 'uptimer'...
Deploying 'uptimer_GREEN' in place of 'uptimer_BLUE'...
06f5bc70e9c4f930e7b1f826ae2ca2f536023cc01e82c2b97b2c84d68048b18a
Container started. Checking health...
Requesting 'http://uptimer_GREEN:8080/' within the 'web-gateway' docker network:
  HTTP/1.0 503 Service Unavailable
wget: server returned error: HTTP/1.0 503 Service Unavailable
New 'uptimer_GREEN' service is not ready yet. Waiting (1)...
Requesting 'http://uptimer_GREEN:8080/' within the 'web-gateway' docker network:
  HTTP/1.0 503 Service Unavailable
wget: server returned error: HTTP/1.0 503 Service Unavailable
New 'uptimer_GREEN' service is not ready yet. Waiting (2)...
Requesting 'http://uptimer_GREEN:8080/' within the 'web-gateway' docker network:
  HTTP/1.0 200 OK
  Server: BaseHTTP/0.6 Python/3.8.3
  Date: Sat, 22 Aug 2020 20:15:50 GMT
  Content-Type: text/html

New 'uptimer_GREEN' service seems OK. Switching heads...
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
2020/08/22 20:15:54 [notice] 97#97: signal process started
The 'uptimer_GREEN' service is live!
Killing 'uptimer_BLUE'...
uptimer_BLUE
Total reclaimed space: 0B
Deployment successful!

ឥឡូវនេះអ្នកអាចបើក http://localhost/ នៅក្នុងកម្មវិធីរុករកតាមអ៊ីនធឺណិត ដំណើរការការដាក់ពង្រាយម្តងទៀត ហើយត្រូវប្រាកដថាវាដំណើរការដោយរលូនដោយធ្វើបច្ចុប្បន្នភាពទំព័រដោយយោងតាមស៊ីឌីកំឡុងពេលប្លង់។

កុំភ្លេចសម្អាតក្រោយពេលធ្វើការ៖ ៣

$ docker rm -f uptimer_GREEN reverse-proxy 
uptimer_GREEN
reverse-proxy

$ docker network rm web-gateway 
web-gateway

$ cd ..

$ rm -r blue-green-deployment

ប្រភព: www.habr.com

ការដាក់ពង្រាយពណ៌ខៀវបៃតងនៅប្រាក់ឈ្នួលអប្បបរមា

RЎRμSЂRІRёSЃ

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

បោះពុម្ព

ប្រូកស៊ីបញ្ច្រាស

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

បោះពុម្ព

ការដាក់ពង្រាយគ្មានថ្នេរ

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

បោះពុម្ព

ការផ្ទេររូបភាព

deploy.sh

បច្ចេកទេសគួរឱ្យចាប់អារម្មណ៍

ស្គ្រីបដាក់ឱ្យប្រើប្រាស់

ដំណើរការស្គ្រីបដែលបានកំណត់ប៉ារ៉ាម៉ែត្រនៅលើម៉ាស៊ីនមេពីចម្ងាយ

កុំ​ភ្លេច​សម្អាត​ក្រោយ​ពេល​ធ្វើ​ការ៖ ៣

`deploy.sh`

កុំភ្លេចសម្អាតក្រោយពេលធ្វើការ៖ ៣