Neste artigo usamos , , и Organizaremos um layout integrado do aplicativo da web. é uma técnica que permite atualizar instantaneamente um aplicativo sem rejeitar uma única solicitação. É uma das estratégias de implantação com tempo de inatividade zero e é mais adequada para aplicativos com uma instância, mas com a capacidade de carregar uma segunda instância pronta para execução nas proximidades.
Digamos que você tenha um aplicativo da web com o qual muitos clientes estão trabalhando ativamente e não há como ele parar por alguns segundos. E você realmente precisa lançar uma atualização de biblioteca, uma correção de bug ou um novo recurso interessante. Em uma situação normal, você precisará interromper o aplicativo, substituí-lo e iniciá-lo novamente. No caso do docker, você pode primeiro substituí-lo e depois reiniciá-lo, mas ainda haverá um período em que as solicitações à aplicação não serão processadas, pois normalmente a aplicação demora algum tempo para carregar inicialmente. E se começar, mas ficar inoperante? Este é o problema, vamos resolvê-lo com o mínimo de meios e da forma mais elegante possível.
AVISO LEGAL: A maior parte do artigo é apresentada em formato experimental - na forma de uma gravação de uma sessão de console. Esperamos que isso não seja muito difícil de entender e que o código se documente suficientemente. Para a atmosfera, imagine que não se trata apenas de trechos de código, mas de papel de um teletipo de “ferro”.
Técnicas interessantes que são difíceis de pesquisar no Google apenas pela leitura do código são descritas no início de cada seção. Se alguma coisa não estiver clara, pesquise no Google e confira. (felizmente voltou a funcionar, devido ao desbloqueio do telegrama). Se você não consegue nada no Google, pergunte nos comentários. Terei prazer em acrescentar à seção correspondente “Técnicas interessantes”.
Vamos começar
$ mkdir blue-green-deployment && cd $_Serviço
Vamos fazer um serviço experimental e colocá-lo em um container.
Técnicas interessantes
cat << EOF > file-name( + ) é uma maneira de criar um arquivo multilinhas com um comando. Tudo o que o bash lê/dev/stdindepois desta linha e antes da linhaEOFserá gravado emfile-name.wget -qO- URL() — envia um documento recebido via HTTP para/dev/stdout(análogocurl URL).
Imprimir
Eu quebro especificamente o snippet para ativar o destaque para Python. No final haverá outra peça como esta. Considere que nesses locais o papel era cortado para ser enviado ao departamento de destaque (onde o código era colorido à mão com marcadores), e depois esses pedaços eram colados novamente.
$ 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
uptimerProxy reverso
Para que nossa aplicação possa mudar despercebida, é necessário que haja alguma outra entidade na frente dela que esconda sua substituição. Poderia ser um servidor web в . Um proxy reverso é estabelecido entre o cliente e o aplicativo. Ele aceita solicitações de clientes e as encaminha para a aplicação e encaminha as respostas da aplicação aos clientes.
O aplicativo e o proxy reverso podem ser vinculados dentro do docker usando . Assim, o contêiner com a aplicação nem precisa encaminhar uma porta no sistema host, o que permite que a aplicação seja isolada ao máximo de ameaças externas.
Se o proxy reverso residir em outro host, você terá que abandonar a rede docker e conectar a aplicação ao proxy reverso através da rede host, encaminhando a porta Aplicativos parâmetro --publish, como na primeira inicialização e como no proxy reverso.
Executaremos o proxy reverso na porta 80, pois é exatamente esta a entidade que deve escutar a rede externa. Se a porta 80 estiver ocupada no seu host de teste, altere o parâmetro --publish 80:80 em --publish ANY_FREE_PORT:80.
Técnicas interessantes
- “Em redes Docker criadas por usuários, você pode se comunicar com contêineres não apenas por endereço IP. O nome do contêiner também é resolvido em seu endereço IP" (, ponto 5 do código docker).
Imprimir
$ 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>Implantação perfeita
Vamos lançar uma nova versão do aplicativo (com um aumento duplo no desempenho de inicialização) e tentar implantá-lo perfeitamente.
Técnicas interessantes
echo 'my text' | docker exec -i my-container sh -c 'cat > /my-file.txt'- Escrever textomy textarquivar/my-file.txtdentro do recipientemy-container.cat > /my-file.txt— Grava o conteúdo da entrada padrão em um arquivo/dev/stdin.
Imprimir
$ 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-proxyNesta fase, a imagem é construída diretamente no servidor, o que exige que as fontes da aplicação estejam lá, e também carrega o servidor com trabalho desnecessário. A próxima etapa é alocar o conjunto de imagens para uma máquina separada (por exemplo, para um sistema CI) e depois transferi-lo para o servidor.
Transferindo imagens
Infelizmente, não faz sentido transferir imagens de localhost para localhost, então esta seção só pode ser explorada se você tiver dois hosts com Docker em mãos. No mínimo é algo assim:
$ 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.9MBEquipe docker save salva os dados da imagem em um arquivo .tar, o que significa que pesa cerca de 1.5 vezes mais do que pesaria na forma compactada. Então, vamos agitar em nome da economia de tempo e tráfego:
$ docker image save uptimer | gzip | ssh production-server 'zcat | docker image load'
Loaded image: uptimer:latestVocê também pode monitorar o processo de download (embora isso exija um utilitário de terceiros):
$ docker image save uptimer | gzip | pv | ssh production-server 'zcat | docker image load'
25,7MiB 0:01:01 [ 425KiB/s] [ <=> ]
Loaded image: uptimer:latestDica: Se você precisar de vários parâmetros para se conectar a um servidor via SSH, talvez não esteja usando o arquivo
~/.ssh/config.
Transferindo a imagem via docker image save/load - Este é o método mais minimalista, mas não o único. Há outros:
- Registro de contêineres (padrão da indústria).
- Conecte-se ao servidor docker daemon de outro host:
- variável de ambiente
DOCKER_HOST. - Opção de linha de comando
-Hou--hostinstrumentodocker-compose. docker context
- variável de ambiente
O segundo método (com três opções para sua implementação) está bem descrito no artigo .
deploy.sh
Agora vamos reunir tudo o que fizemos manualmente em um script. Vamos começar com a função de nível superior e depois examinar as outras usadas nela.
Técnicas interessantes
${parameter?err_msg}- um dos feitiços mágicos do bash (também conhecido como ) Se umparameternão especificado, saídaerr_msge saia com o código 1.docker --log-driver journald— por padrão, o driver de registro do docker é um arquivo de texto sem qualquer rotação. Com essa abordagem, os logs ocupam rapidamente todo o disco, portanto para um ambiente de produção é necessário trocar o driver por um mais inteligente.
Script de implantação
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
}Recursos usados:
ensure-reverse-proxy— Garante que o proxy reverso esteja funcionando (útil para a primeira implantação)get-active-slot service_name— Determina qual slot está atualmente ativo para um determinado serviço (BLUEouGREEN)get-service-status service_name deployment_slot— Determina se o serviço está pronto para processar solicitações recebidasset-active-slot service_name deployment_slot— Altera a configuração do nginx no contêiner de proxy reverso
Em ordem:
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
}Função get-active-slot requer uma pequena explicação:
Por que ele retorna um número e não gera uma string?
De qualquer forma, na função de chamada verificamos o resultado do seu trabalho, e verificar o código de saída usando o bash é muito mais fácil do que verificar uma string. Além disso, obter uma string dele é muito simples:
get-active-slot service && echo BLUE || echo GREEN.
Serão três condições realmente suficientes para distinguir todos os estados?
Até dois serão suficientes, o último está aqui apenas para completar, para não escrever else.
Apenas a função que retorna as configurações do nginx permanece indefinida: get-nginx-config service_name deployment_slot. Por analogia com a verificação de integridade, aqui você pode definir qualquer configuração para qualquer serviço. Das coisas interessantes - apenas cat <<- EOF, que permite remover todas as guias no início. É verdade que o preço de uma boa formatação é misturar tabulações com espaços, o que hoje é considerado de péssima forma. Mas o bash força as guias, e também seria bom ter formatação normal na configuração do nginx. Resumindo, misturar tabulações com espaços aqui realmente parece ser a melhor solução entre as piores. No entanto, você não verá isso no trecho abaixo, já que Habr “faz isso bem” alterando todas as tabulações para 4 espaços e tornando EOF inválido. .
Para não se levantar duas vezes, contarei imediatamente sobre
cat << 'EOF', que será encontrado posteriormente. Se você escrever simplesmentecat << EOF, então dentro do heredoc a string é interpolada (as variáveis são expandidas ($foo), chamadas de comando ($(bar)) etc.), e se você colocar o final do documento entre aspas simples, a interpolação será desativada e o símbolo$é exibido como está. O que você precisa para inserir um script dentro de outro 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
}Este é o roteiro completo. E assim para download via wget ou curl.
Executando scripts parametrizados em um servidor remoto
É hora de bater no servidor de destino. Desta vez localhost bastante adequado:
$ 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.Escrevemos um script de implantação que baixa uma imagem pré-construída para o servidor de destino e substitui perfeitamente o contêiner de serviço, mas como podemos executá-lo em uma máquina remota? O script possui argumentos, pois é universal e pode implantar vários serviços ao mesmo tempo em um proxy reverso (você pode usar configurações do nginx para determinar qual URL será qual serviço). O script não pode ser armazenado no servidor, pois neste caso não poderemos atualizá-lo automaticamente (para fins de correção de bugs e adição de novos serviços), e em geral, estado = mal.
Solução 1: ainda armazene o script no servidor, mas copie-o sempre scp. Em seguida, conecte-se através ssh e execute o script com os argumentos necessários.
Contras:
- Duas ações em vez de uma
- Pode não haver um local para copiar, ou pode não haver acesso a ele, ou o script pode ser executado no momento da substituição.
- É aconselhável limpar você mesmo (excluir o script).
- Já três ações.
Solução 2:
- Mantenha apenas as definições de função no script e não execute nada
- Com
sedadicione uma chamada de função ao final - Envie tudo diretamente para shh via pipe (
|)
Prós:
- Verdadeiramente apátrida
- Nenhuma entidade padronizada
- Sentindo-se legal
Vamos fazer isso sem Ansible. Sim, tudo já foi inventado. Sim, uma bicicleta. Veja como a moto é simples, elegante e minimalista:
$ 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'No entanto, não podemos ter certeza de que o host remoto tenha o bash adequado, então adicionaremos uma pequena verificação no início (isto é, em vez de ):
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
fiE agora é real:
$ 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!Agora você pode abrir no navegador, execute a implantação novamente e certifique-se de que ela funcione perfeitamente, atualizando a página de acordo com o CD durante o layout.
Não se esqueça de limpar depois do trabalho :3
$ docker rm -f uptimer_GREEN reverse-proxy
uptimer_GREEN
reverse-proxy
$ docker network rm web-gateway
web-gateway
$ cd ..
$ rm -r blue-green-deploymentFonte: habr.com