🥇Imscaradh Gorm-Uaine ar a laghad

San Airteagal seo úsáidimid Eabhrac, ssh, docker и nginx Eagróimid leagan amach gan uaim den fheidhmchlár gréasáin. Imscaradh gorm-uaine is teicníocht é a ligeann duit feidhmchlár a nuashonrú láithreach gan diúltú d’iarratas amháin. Tá sé ar cheann de na straitéisí imlonnaithe náid aga neamhfhónaimh agus is fearr a oireann d’fheidhmchláir le cás amháin, ach tá an cumas an dara hásc réidh le rith a luchtú in aice láimhe.

Ligean le rá go bhfuil feidhmchlár gréasáin agat a bhfuil go leor cliant ag obair go gníomhach leis, agus níl aon bhealach ann dó luí síos ar feadh cúpla soicind. Agus ní mór duit i ndáiríre nuashonrú leabharlainne, réiteach fabhtanna, nó gné fionnuar nua a rolladh amach. I gcás gnáth, beidh ort an t-iarratas a stopadh, é a athsholáthar agus é a thosú arís. I gcás docker, is féidir leat é a athsholáthar ar dtús, ansin é a atosú, ach beidh tréimhse fós ann nach ndéanfar iarratais ar an iarratas a phróiseáil, mar de ghnáth tógann an t-iarratas roinnt ama chun é a luchtú ar dtús. Cad a tharlaíonn má thosaíonn sé, ach go casadh amach a bheith neamh-inoibrithe? Is é seo an fhadhb, déanaimis é a réiteach le modhanna íosta agus chomh galánta agus is féidir.

SÉANADH: Cuirtear an chuid is mó den alt i láthair i bhformáid thurgnamhach - i bhfoirm taifeadta de sheisiún consól. Táthar ag súil nach mbeidh sé seo ró-dheacair a thuiscint agus go ndéanfaidh an cód doiciméadú leordhóthanach air féin. Maidir le hatmaisféar, samhlaigh nach míreanna cód amháin iad seo, ach páipéar ó theilitype “iarann”.

Déantar cur síos ar theicnící suimiúla atá deacair do Google ach an cód a léamh ag tús gach ailt. Mura bhfuil aon rud soiléir, google é agus seiceáil amach é. Míníonn (Go fortunately, oibríonn sé arís, mar gheall ar dhíbhlocáil an teileagraim). Mura féidir leat rud ar bith a Google, fiafraigh sna tuairimí. Beidh áthas orm cur leis an rannán comhfhreagrach “Teicnící suimiúil”.

Let's tús.

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

TSeirbhís

Déanaimis seirbhís thurgnamhach agus cuirfimid i gcoimeádán é.

Teicnící suimiúil

cat << EOF > file-name (Seo Doiciméad + Atreorú I/O) is bealach é chun comhad illíne a chruthú le hordú amháin. Gach rud bash léann ó /dev/stdin tar éis na líne seo agus roimh an líne EOF a thaifeadadh i file-name.
wget -qO- URL (Míníonn) — doiciméad a fuarthas trí HTTP a aschur chuig /dev/stdout (analóg curl URL).

Priontáil amach

Briseann mé an blúire go sonrach chun béim a chur ar Python. Ag an deireadh beidh píosa eile mar seo. Smaoinigh gur gearradh an páipéar sna háiteanna seo le seoladh chuig an roinn aibhsithe (áit a ndearnadh an cód a dhathú de láimh le aibhsitheoirí), agus ansin greamaíodh na píosaí seo ar ais.

$ 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

seachfhreastalaí droim ar ais

Ionas go mbeidh ár n-iarratas in ann athrú nach dtugtar faoi deara, ní mór aonán éigin eile a bheith os a chomhair a chuirfidh a ionad i bhfolach. D'fhéadfadh sé a bheith ina fhreastalaí gréasáin nginx в mód seachfhreastalaí droim ar ais. Bunaítear seachfhreastalaí droim ar ais idir an cliant agus an feidhmchlár. Glacann sé le hiarratais ó chliaint agus cuireann sé ar aghaidh chuig an iarratas iad agus cuireann sé freagraí an iarratais ar aghaidh chuig na cliaint.

Is féidir an t-iarratas agus an seachfhreastalaí droim ar ais a nascadh taobh istigh de dhugóir ag baint úsáide as líonra docker. Mar sin, ní gá fiú an coimeádán leis an bhfeidhmchlár a chur ar aghaidh ar an gcóras óstaigh; ceadaíonn sé seo an t-iarratas a bheith scoite amach uasta ó bhagairtí seachtracha.

Má chónaíonn an seachfhreastalaí droim ar ais ar óstaigh eile, beidh ort an líonra docker a thréigean agus an feidhmchlár a nascadh leis an seachfhreastalaí droim ar ais tríd an líonra óstaigh, ag cur an port ar aghaidh apps paraiméadar --publish, mar atá ag an gcéad tús agus mar atá leis an seachfhreastalaí droim ar ais.

Reáchtálfaimid an seachfhreastalaí droim ar ais ar phort 80, toisc gurb é seo go díreach an t-eintiteas ar cheart éisteacht leis an líonra seachtrach. Má tá port 80 gnóthach ar d’óstach tástála, athraigh an paraiméadar --publish 80:80 ar --publish ANY_FREE_PORT:80.

Teicnící suimiúil

“I líonraí Docker cruthaithe ag úsáideoirí, is féidir leat cumarsáid a dhéanamh le coimeádáin, ní hamháin trí sheoladh IP. Réitítear ainm an choimeádáin ina sheoladh IP freisin" (alt “Líonra le coimeádáin neamhspleácha”, cuid “Úsáid líonraí droichead atá sainithe ag an úsáideoir”, pointe 5 den chód docker).

Priontáil amach

$ 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>

Imscaradh gan uaim

Déanaimis leagan nua den fheidhmchlár a rolladh amach (le treisiú feidhmíochta tosaithe faoi dhó) agus déanfaimid iarracht é a imscaradh gan uaim.

Teicnící suimiúil

echo 'my text' | docker exec -i my-container sh -c 'cat > /my-file.txt' — Scríobh téacs my text a chomhdú /my-file.txt taobh istigh den choimeádán my-container.
cat > /my-file.txt — Scríobh inneachar an ionchuir chaighdeánaigh i gcomhad /dev/stdin.

Priontáil amach

$ 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

Ag an gcéim seo, tógtar an íomhá go díreach ar an bhfreastalaí, rud a éilíonn go mbeidh na foinsí iarratais ann, agus go n-ualach an freastalaí freisin le hobair gan ghá. Is é an chéad chéim eile ná an tionól íomhá a leithdháileadh ar mheaisín ar leith (mar shampla, chuig córas CI) agus ansin é a aistriú chuig an bhfreastalaí.

Íomhánna a aistriú

Ar an drochuair, ní dhéanann sé ciall íomhánna a aistriú ó localhost go localhost, mar sin ní féidir an chuid seo a iniúchadh ach amháin má tá dhá óstach agat le Docker ar láimh. Ar a laghad breathnaíonn sé rud éigin mar seo:

$ 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

Foireann docker save sábhálann sé na sonraí íomhá i gcartlann .tar, rud a chiallaíonn go bhfuil sé thart ar 1.5 uair níos mó ná mar a mheáfadh sé i bhfoirm chomhbhrúite. Mar sin déanaimis é a chroitheadh in ainm shábháil am agus tráchta:

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

Is féidir leat freisin monatóireacht a dhéanamh ar an bpróiseas íoslódála (cé go bhfuil gá le fóntais tríú páirtí):

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

Leid: Más gá duit a lán paraiméadair chun ceangal le freastalaí trí SSH, b'fhéidir nach bhfuil tú ag baint úsáide as an gcomhad ~/.ssh/config.

An íomhá a aistriú trí docker image save/load - Is é seo an modh is minimalistic, ach ní an ceann amháin. Tá daoine eile:

Clárlann Coimeádán (caighdeán tionscail).
Ceangail le freastalaí deamhan docker ó óstach eile:
1. athróg timpeallachta DOCKER_HOST.
2. Rogha líne ordaithe -H nó --host ionstraim docker-compose.
3. docker context

Tá cur síos maith ar an dara modh (le trí rogha maidir lena chur i bhfeidhm) san alt Conas a imscaradh ar óstaigh Docker iargúlta le docker-compose.

`deploy.sh`

Anois, déanaimis gach rud a rinne muid a bhailiú de láimh i script amháin. Tosaímid leis an bhfeidhm barrleibhéil, agus ansin féachaint ar na cinn eile a úsáidtear inti.

Teicnící suimiúil

${parameter?err_msg} - ceann de na geasa draíochta bash (aka ionadú paraiméadar). Dá parameter nach bhfuil sonraithe, aschur err_msg agus scoir le cód 1.
docker --log-driver journald - de réir réamhshocraithe, is comhad téacs é an tiománaí logála docker gan aon rothlú. Leis an gcur chuige seo, líonann na logaí an diosca iomlán go tapa, mar sin le haghaidh timpeallacht táirgthe is gá an tiománaí a athrú go ceann níos cliste.

Script imscaradh

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
}

Gnéithe a úsáideadh:

ensure-reverse-proxy — Cinntigh go bhfuil an seachfhreastalaí droim ar ais ag obair (úsáideach don chéad imscaradh)
get-active-slot service_name — Cinneann sé cén sliotán atá gníomhach faoi láthair do sheirbhís ar leith (BLUE nó GREEN)
get-service-status service_name deployment_slot — Cinneann sé an bhfuil an tseirbhís réidh chun iarratais a thagann isteach a phróiseáil
set-active-slot service_name deployment_slot — Athraíonn an chumraíocht nginx sa choimeádán seachfhreastalaí droim ar ais

In ord:

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
}

Feidhm get-active-slot tá míniú beag ag teastáil:

Cén fáth a dtugann sé uimhir ar ais agus nach n-aschuireann sé sreang?

Ar aon nós, sa fheidhm ghlao déanaimid seiceáil ar thoradh a chuid oibre, agus tá sé i bhfad níos éasca cód scoir a sheiceáil ag baint úsáide as bash ná teaghrán a sheiceáil. Ina theannta sin, tá sé an-simplí sreang a fháil uaidh:
get-active-slot service && echo BLUE || echo GREEN.

An leor trí choinníoll i ndáiríre chun idirdhealú a dhéanamh idir gach stát?

Beidh fiú dhá cheann go leor, tá an ceann deireanach anseo ach le haghaidh iomláine, ionas nach a scríobh else.

Níl ach an fheidhm a sheolann cumraíochtaí nginx ar ais fós neamhshainithe: get-nginx-config service_name deployment_slot. De réir analaí le seiceáil sláinte, anseo is féidir leat aon config a shocrú le haghaidh aon seirbhíse. De na rudaí suimiúla - amháin cat <<- EOF, a ligeann duit gach cluaisín a bhaint ag an tús. True, tá an praghas formáidiú maith cluaisíní measctha le spásanna, a mheastar sa lá atá inniu bhfoirm an-dona. Ach fórsaí bash tabs, agus bheadh sé deas freisin go mbeadh formáidiú gnáth sa nginx config. I mbeagán focal, is cosúil gurb é an réiteach is fearr as an gceann is measa ná cluaisíní a mheascadh le spásanna anseo. Ní fheicfidh tú é seo sa ghearrthóg thíos, áfach, ós rud é go ndéanann Habr “go maith” trí gach cluaisín a athrú go 4 spás agus EOF a dhéanamh neamhbhailí. Agus anseo tá sé faoi deara.

Ionas nach n-éireoidh mé faoi dhó, inseoidh mé duit ar an bpointe boise cat << 'EOF', a bheidh le teacht níos déanaí. Má scríobhann tú go simplí cat << EOF, ansin laistigh de heredoc tá an téad idirshuite (méadaítear na hathróga ($foo), glaonna ordaithe ($(bar)) srl.), agus má chuireann tú deireadh an doiciméid isteach i Sleachta singil, díchumasaítear idirshuíomh agus an tsiombail $ ar taispeáint mar atá. Cad is gá duit a chur isteach script taobh istigh eile script.

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
}

Is é seo an script ar fad. Agus mar sin gist leis an script seo Le híoslódáil trí wget nó curl.

Scripteanna paraiméadaraithe a rith ar chianfhreastalaí

Tá sé in am cnag a chur ar an spriocfhreastalaí. An am seo localhost oiriúnach go leor:

$ 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.

Táimid tar éis script imscaradh a scríobh a íoslódálann íomhá réamhthógtha chuig an spriocfhreastalaí agus a athsholáthróidh an coimeádán seirbhíse gan uaim, ach conas is féidir linn é a fhorghníomhú ar mheaisín iargúlta? Tá argóintí ag an script, ós rud é go bhfuil sé uilíoch agus gur féidir léi roinnt seirbhísí a imscaradh ag an am céanna faoi seachfhreastalaí droim ar ais amháin (is féidir leat cumraíochtaí nginx a úsáid chun a chinneadh cé acu url a bheidh ina sheirbhís). Ní féidir an script a stóráil ar an bhfreastalaí, ós rud é sa chás seo ní bheidh muid in ann é a nuashonrú go huathoibríoch (chun críche fabhtanna a cheartú agus seirbhísí nua a chur leis), agus go ginearálta, luaigh = olc.

Réiteach 1: Stóráil fós an script ar an bhfreastalaí, ach cóipeáil é gach uair tríd scp. Ansin ceangail via ssh agus an script a fhorghníomhú leis na hargóintí is gá.

CONS:

Dhá ghníomh in ionad ceann amháin
B’fhéidir nach bhfuil áit ann a ndéanann tú cóipeáil, nó b’fhéidir nach bhfuil rochtain air, nó féadfar an script a fhorghníomhú tráth an ionadaíochta.
Tá sé inmholta a ghlanadh suas i ndiaidh duit féin (scrios an script).
Cheana féin trí ghníomh.

Réiteach 2:

Ná coinnigh ach sainmhínithe feidhme sa script agus ná rith aon rud ar bith
Le sed cuir glao feidhm go dtí an deireadh
Seol ar fad go díreach chuig shh trí phíobán (|)

Son:

Fíor gan stát
Uimh aonáin boilerplate
Mothú fionnuar

A ligean ar a dhéanamh ach é gan Ansible. Sea, tá gach rud invented cheana féin. Sea, rothar. Féach cé chomh simplí, galánta agus íostach atá an rothar:

$ 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'

Mar sin féin, ní féidir linn a bheith cinnte go bhfuil bash leordhóthanach ag an óstach iargúlta, mar sin cuirfimid seiceáil beag leis ag an tús (tá sé seo in ionad sliogán):

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

Agus anois tá sé fíor:

$ 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!

Anois is féidir leat a oscailt http://localhost/ sa bhrabhsálaí, reáchtáil an t-imscaradh arís agus cinntigh go ritheann sé gan uaim tríd an leathanach a nuashonrú de réir an CD le linn an leagan amach.

Ná déan dearmad glanadh suas tar éis obair :3

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

$ docker network rm web-gateway 
web-gateway

$ cd ..

$ rm -r blue-green-deployment

Foinse: will.com