In hierdie artikel gebruik ons , , и Ons sal 'n naatlose uitleg van die webtoepassing organiseer. is 'n tegniek wat jou toelaat om 'n toepassing onmiddellik op te dateer sonder om 'n enkele versoek te verwerp. Dit is een van die nul-stilstand-ontplooiingstrategieë en is die beste geskik vir toepassings met een instansie, maar die vermoë om 'n tweede, gereed om te hardloop instansie naby te laai.
Kom ons sê jy het 'n webtoepassing waarmee baie kliënte aktief werk, en daar is absoluut geen manier waarop dit vir 'n paar sekondes kan lê nie. En jy moet regtig 'n biblioteekopdatering, 'n foutoplossing of 'n nuwe cool funksie uitrol. In 'n normale situasie sal jy die toepassing moet stop, vervang en weer begin. In die geval van docker kan jy dit eers vervang, dan weer begin, maar daar sal steeds 'n tydperk wees waarin versoeke na die aansoek nie verwerk sal word nie, want gewoonlik neem die aansoek 'n rukkie om aanvanklik te laai. Wat as dit begin, maar blyk onwerkbaar te wees? Dit is die probleem, kom ons los dit op met minimale middele en so elegant as moontlik.
VRYWARING: Die meeste van die artikel word in 'n eksperimentele formaat aangebied - in die vorm van 'n opname van 'n konsolesessie. Hopelik sal dit nie te moeilik wees om te verstaan nie en sal die kode homself voldoende dokumenteer. Vir atmosfeer, stel jou voor dat dit nie net kodebrokkies is nie, maar papier van 'n "yster" teletipe.
Interessante tegnieke wat moeilik is om te Google net deur die kode te lees, word aan die begin van elke afdeling beskryf. As enigiets anders onduidelik is, google dit en kyk daarna. (gelukkig werk dit weer, as gevolg van die deblokkering van die telegram). As jy niks kan Google nie, vra in die kommentaar. Ek sal graag by die ooreenstemmende afdeling "Interessante tegnieke" byvoeg.
Laat ons begin.
$ mkdir blue-green-deployment && cd $_Service
Kom ons maak 'n eksperimentele diens en plaas dit in 'n houer.
Interessante tegnieke
cat << EOF > file-name( + ) is 'n manier om 'n multi-lyn lêer met een opdrag te skep. Alles bash lees uit/dev/stdinna hierdie lyn en voor die lynEOFsal aangeteken word infile-name.wget -qO- URL() — voer 'n dokument uit wat via HTTP ontvang is na/dev/stdout(analoogcurl URL).
Drukstuk
Ek breek spesifiek die brokkie om uitlig vir Python moontlik te maak. Aan die einde sal daar nog 'n stuk soos hierdie wees. Neem in ag dat die papier op hierdie plekke gesny is om na die uitligafdeling gestuur te word (waar die kode met die hand ingekleur is met highlighters), en dan is hierdie stukke teruggeplak.
$ cat << EOF > uptimer.pyfrom 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
uptimerOmgekeerde proxy
Om ons aansoek ongemerk te kan verander, is dit nodig dat daar 'n ander entiteit voor dit is wat die vervanging daarvan sal verberg. Dit kan 'n webbediener wees в . 'n Omgekeerde proxy word tussen die kliënt en die toepassing gevestig. Dit aanvaar versoeke van kliënte en stuur dit aan na die aansoek en stuur die aansoek se antwoorde aan die kliënte.
Die toepassing en omgekeerde instaanbediener kan in die docker gekoppel word met behulp van . Dus, die houer met die toepassing hoef nie eers 'n poort op die gasheerstelsel aan te stuur nie; dit laat die toepassing maksimaal geïsoleer word van eksterne bedreigings.
As die omgekeerde instaanbediener op 'n ander gasheer woon, sal jy die koppelaarnetwerk moet laat vaar en die toepassing aan die omgekeerde instaanbediener moet koppel deur die gasheernetwerk, en die poort moet aanstuur programme parameter --publish, soos by die eerste begin en soos met die omgekeerde proxy.
Ons sal die omgekeerde instaanbediener op poort 80 laat loop, want dit is presies die entiteit wat na die eksterne netwerk moet luister. As poort 80 op jou toetsgasheer besig is, verander die parameter --publish 80:80 op --publish ANY_FREE_PORT:80.
Interessante tegnieke
- “In Docker-netwerke wat deur gebruikers geskep is, kan jy met houers kommunikeer nie net deur IP-adres nie. Die houernaam word ook in sy IP-adres opgelos" (, punt 5 van die docker-kode).
Drukstuk
$ 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>Naatlose ontplooiing
Kom ons ontplooi 'n nuwe weergawe van die toepassing (met 'n tweevoudige opstartwerkverrigtingverhoging) en probeer om dit naatloos te ontplooi.
Interessante tegnieke
echo 'my text' | docker exec -i my-container sh -c 'cat > /my-file.txt'- Skryf teksmy textom te liasseer/my-file.txtbinne die houermy-container.cat > /my-file.txt— Skryf die inhoud van standaardinvoer na 'n lêer/dev/stdin.
Drukstuk
$ 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-proxyOp hierdie stadium word die beeld direk op die bediener gebou, wat vereis dat die toepassingsbronne daar moet wees, en laai ook die bediener met onnodige werk. Die volgende stap is om die beeldsamestelling aan 'n aparte masjien toe te ken (byvoorbeeld aan 'n CI-stelsel) en dit dan na die bediener oor te dra.
Dra beelde oor
Ongelukkig maak dit nie sin om beelde van localhost na localhost oor te dra nie, so hierdie afdeling kan slegs verken word as u twee gashere het met Docker byderhand. Ten minste lyk dit so:
$ 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.9MBSpan docker save stoor die beelddata in 'n .tar-argief, wat beteken dit weeg ongeveer 1.5 keer meer as wat dit in saamgeperste vorm sou weeg. Laat ons dit dus skud in die naam om tyd en verkeer te bespaar:
$ docker image save uptimer | gzip | ssh production-server 'zcat | docker image load'
Loaded image: uptimer:latestU kan ook die aflaaiproses monitor (hoewel dit 'n derdeparty-hulpmiddel vereis):
$ docker image save uptimer | gzip | pv | ssh production-server 'zcat | docker image load'
25,7MiB 0:01:01 [ 425KiB/s] [ <=> ]
Loaded image: uptimer:latestWenk: As jy 'n klomp parameters nodig het om aan 'n bediener via SSH te koppel, gebruik jy dalk nie die lêer nie
~/.ssh/config.
Dra die beeld oor via docker image save/load - Dit is die mees minimalistiese metode, maar nie die enigste nie. Daar is ander:
- Houerregister (bedryfstandaard).
- Koppel aan docker daemon-bediener vanaf 'n ander gasheer:
- omgewingsveranderlike
DOCKER_HOST. - Command line opsie
-Hof--hostinstrumentdocker-compose. docker context
- omgewingsveranderlike
Die tweede metode (met drie opsies vir die implementering daarvan) word goed beskryf in die artikel .
deploy.sh
Kom ons versamel nou alles wat ons met die hand gedoen het in een skrif. Kom ons begin met die topvlakfunksie, en kyk dan na die ander wat daarin gebruik word.
Interessante tegnieke
${parameter?err_msg}- een van die bash magiese towerspreuke (aka ). Asparameternie gespesifiseer nie, uitseterr_msgen gaan uit met kode 1.docker --log-driver journald- by verstek is die docker-logbestuurder 'n tekslêer sonder enige rotasie. Met hierdie benadering maak die logs vinnig die hele skyf vol, so vir 'n produksie-omgewing is dit nodig om die drywer na 'n slimmer een te verander.
Ontplooiingskrip
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
}Kenmerke wat gebruik word:
ensure-reverse-proxy- Maak seker dat die omgekeerde instaanbediener werk (nuttig vir die eerste ontplooiing)get-active-slot service_name— Bepaal watter gleuf tans aktief is vir 'n gegewe diens (BLUEofGREEN)get-service-status service_name deployment_slot— Bepaal of die diens gereed is om inkomende versoeke te verwerkset-active-slot service_name deployment_slot— Verander die nginx-konfigurasie in die omgekeerde instaanbedienerhouer
In volgorde:
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
}Funksie get-active-slot vereis 'n bietjie verduideliking:
Hoekom gee dit 'n getal terug en voer nie 'n string uit nie?
In elk geval, in die oproepfunksie gaan ons die resultaat van sy werk na, en om uitgangkode te kontroleer met bash is baie makliker as om 'n string na te gaan. Daarbenewens is dit baie eenvoudig om 'n tou daaruit te kry:
get-active-slot service && echo BLUE || echo GREEN.
Is drie voorwaardes werklik genoeg om alle state te onderskei?
Selfs twee sal genoeg wees, die laaste een is hier net vir volledigheid, om nie te skryf nie else.
Slegs die funksie wat nginx-konfigurasies terugstuur, bly ongedefinieerd: get-nginx-config service_name deployment_slot. In analogie met gesondheidskontrole kan u hier enige konfigurasie vir enige diens instel. Van die interessante dinge - net cat <<- EOF, wat jou toelaat om alle oortjies aan die begin te verwyder. Die prys van goeie formatering is weliswaar gemengde oortjies met spasies, wat vandag as baie slegte vorm beskou word. Maar bash dwing oortjies af, en dit sal ook lekker wees om normale formatering in die nginx-konfigurasie te hê. Kortom, om oortjies met spasies hier te meng, lyk regtig na die beste oplossing uit die ergste. U sal dit egter nie in die brokkie hieronder sien nie, aangesien Habr "dit goed doen" deur alle oortjies na 4 spasies te verander en EOF ongeldig te maak. .
Om nie twee keer op te staan nie, sal ek jou dadelik vertel van
cat << 'EOF', wat later teëgekom sal word. As jy eenvoudig skryfcat << EOF, dan binne heredoc word die string geïnterpoleer (veranderlikes word uitgebrei ($foo), beveloproepe ($(bar)) ens.), en as jy die einde van dokument in enkele aanhalingstekens insluit, dan is interpolasie gedeaktiveer en die simbool$word vertoon soos dit is. Wat jy nodig het om 'n skrif in 'n ander skrif in te voeg.
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
}Dit is die hele draaiboek. En so vir aflaai via wget of curl.
Uitvoer van geparameteriseerde skrifte op 'n afgeleë bediener
Dit is tyd om op die teikenbediener aan te klop. Hierdie keer localhost redelik geskik:
$ 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.Ons het 'n ontplooiingskrip geskryf wat 'n voorafgeboude prent na die teikenbediener aflaai en die dienshouer naatloos vervang, maar hoe kan ons dit op 'n afgeleë masjien uitvoer? Die skrip het argumente, aangesien dit universeel is en verskeie dienste gelyktydig onder een omgekeerde instaanbediener kan ontplooi (jy kan nginx-konfigurasies gebruik om te bepaal watter url watter diens sal wees). Die skrip kan nie op die bediener gestoor word nie, aangesien ons dit in hierdie geval nie outomaties sal kan opdateer nie (vir die doel van foutoplossings en die byvoeging van nuwe dienste), en in die algemeen, state = evil.
Oplossing 1: Stoor steeds die skrip op die bediener, maar kopieer dit elke keer deur scp. Koppel dan via ssh en voer die skrif uit met die nodige argumente.
Nadele:
- Twee aksies in plaas van een
- Daar is dalk nie 'n plek waar jy kopieer nie, of daar is dalk nie toegang daartoe nie, of die skrif kan uitgevoer word ten tyde van vervanging.
- Dit is raadsaam om agter jouself skoon te maak (vee die skrif uit).
- Reeds drie aksies.
Oplossing 2:
- Hou slegs funksie definisies in die script en voer niks uit nie
- Met
sedvoeg 'n funksie oproep aan die einde - Stuur dit alles direk na shh via pyp (
|)
Pros:
- Werklik staatloos
- Geen boilerplate-entiteite nie
- Voel koel
Kom ons doen dit net sonder Ansible. Ja, alles is reeds uitgevind. Ja, 'n fiets. Kyk hoe eenvoudig, elegant en minimalisties die fiets is:
$ 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_SCRIPTEOF
$ 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'Ons kan egter nie seker wees dat die afgeleë gasheer voldoende bash het nie, so ons sal 'n klein tjek aan die begin byvoeg (dit is in plaas van ):
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
fiEn nou is dit waar:
$ 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!Nou kan jy oopmaak in die blaaier, voer die ontplooiing weer uit en maak seker dat dit naatloos loop deur die bladsy op te dateer volgens die CD tydens die uitleg.
Moenie vergeet om skoon te maak na werk nie :3
$ docker rm -f uptimer_GREEN reverse-proxy
uptimer_GREEN
reverse-proxy
$ docker network rm web-gateway
web-gateway
$ cd ..
$ rm -r blue-green-deploymentBron: will.com