4

Prévia do material em texto

DESCRIÇÃO
Conceitos importantes sobre automatização da implantação, escalonamento e gerenciamento de aplicações
via Kubernetes e via OpenShift, computação acelerada por GPU com Python e Docker Swarm.
PROPÓSITO
O emprego de ferramentas avançadas de desenvolvimento permite ao DevSecOps (desenvolvimento,
segurança e operação) obter agilidade, segurança e ganho de produtividade. Portanto, é importante
compreender os conceitos envolvidos e escolher soluções adequadas, como Kubernetes e OpenShift para
automatizar a implantação, o escalonamento e o gerenciamento de aplicações; e de computação acelerada
por GPU com Python e Docker Swarm.
PREPARAÇÃO
É necessário um computador com o sistema operacional Linux, podendo ser uma máquina física ou virtual,
com acesso à internet.
OBJETIVOS
MÓDULO 1
Empregar a automatização da implantação, escalonamento e gerenciamento de aplicações via Kubernetes
MÓDULO 2
Empregar a automatização da implantação, escalonamento e gerenciamento de aplicações via OpenShift
MÓDULO 3
Reconhecer computação acelerada por GPU com Python
MÓDULO 4
Descrever Docker Swarm
INTRODUÇÃO
Para entendermos os tópicos avançados em computação distribuída e paralela, iniciaremos apresentando
conceitos importantes sobre containers, seguiremos com um caso de automatização da implantação,
escalonamento e gerenciamento de aplicações via Kubernetes e um caso de automatização da implantação,
escalonamento e gerenciamento de aplicações via OpenShift, ambos na nuvem. Em seguida, estudaremos
um exemplo de uso de computação acelerada por GPU com Python utilizando CUDA/NVIDIA e, por fim,
exemplificaremos o uso do Microsoft Azure com Docker Swarm.
MÓDULO 1
 Empregar a automatização da implantação, escalonamento e gerenciamento de aplicações via
Kubernetes
ESTUDO DE CASO EM NUVEM ‒ INTRODUÇÃO
Com a necessidade de informações precisas para a tomada de decisões, as aplicações, os sistemas e
repositórios de informações vêm aumentando de forma vertiginosa dentro das organizações. A necessidade
de uso de sistemas computacionais aumentou muito a demanda por soluções tecnológicas, tanto em suporte
como em desenvolvimento de sistemas personalizados.
OS RECURSOS DE TECNOLOGIA DA INFORMAÇÃO
TORNARAM-SE DIFERENCIAL ESTRATÉGICO,
AUMENTANDO O POTENCIAL COMPETITIVO DAS
ORGANIZAÇÕES.
Para atender a essa demanda, grandes servidores passaram a utilizar a tecnologia de containers em
substituição às máquinas virtuais.
Máquinas virtuais (VMs)
As máquinas virtuais (VMs) tradicionais permitem a virtualização da infraestrutura de computação.

Containers
Os containers permitem a virtualização de aplicativos de software.
Diferentemente das máquinas virtuais, os containers usam o sistema operacional (SO) do host, em vez de
trazerem um sistema próprio. Como eles não incluem o sistema operacional completo, os containers exigem
recursos computacionais mínimos e são rápidos e fáceis de instalar.
Essa eficiência permite que eles sejam implantados em clusters, com os containers individuais encapsulando
componentes únicos de aplicativos complexos.
Separar os componentes dos aplicativos em containers diferentes permite que os desenvolvedores atualizem
componentes individuais sem retrabalhar todo o aplicativo.
 
Imagem: Shutterstock.com
KUBERNETES
Para facilitar a tarefa de orquestrar microsserviços distribuídos em containers ao longo de clusters, várias
soluções de orquestração foram criadas, entre elas a Kubernetes ou “k8s”, que é uma plataforma de
código aberto, desenvolvida pelo Google e disponibilizada em 2014, portável e extensiva para o
gerenciamento de cargas de trabalho e serviços distribuídos em containers, que facilita tanto a
configuração declarativa quanto a automação dos containers Linux.
Um cluster Kubernetes consiste em um conjunto de servidores de processamento, chamados nós, que
executam aplicações containerizadas. Todo cluster possui ao menos um servidor de processamento (worker
node).
O servidor de processamento hospeda os Pods, que são componentes de uma aplicação. O ambiente de
gerenciamento gerencia os nós de processamento e os Pods no cluster. Em ambientes de produção, o
ambiente de gerenciamento geralmente executa em múltiplos computadores e um cluster geralmente executa
em múltiplos nós (nodes), provendo tolerância a falhas e alta disponibilidade.
KUBERNETES IMPLEMENTA TODOS OS MECANISMOS
DE ALTA DISPONIBILIDADE, ISOLAMENTO E ALTA
PERFORMANCE DE CLUSTERS TRADICIONAIS, SÓ QUE
AQUI, APLICADO AO CONCEITO DE CONTAINERS.
Dessa forma, Kubernetes torna possível a criação de um ambiente crítico e concorrente sob a perspectiva de
microsserviços, totalmente baseado em containers, implementa, ainda, um alto nível de abstração. Essa
abstração, chamada de Pods, faz com que os containers sejam independentes da máquina nó. Dentre
as várias vantagens, está a facilidade de fazer com que um container “enxergue” o(s) outro(s) dentro do
cluster.
Além de possuir interface gráfica que permite monitorar o ambiente de maneira visual, o Kubernetes permite
resolver vários problemas críticos do uso de cluster de containers, entre eles:
Possibilita o deploy de aplicações em containers Docker (mas não apenas ele) de maneira eficiente e
simplificada
Modelo de escala de containers eficiente
Recursos nativos para update de aplicações já existentes
Debug de aplicações já “conteinerizadas” no cluster
Balanceamento de carga entre containers iguais
Os componentes da camada de gerenciamento tomam decisões globais sobre o cluster (por exemplo,
agendamento de Pods), bem como detectam e respondem aos eventos do cluster (por exemplo, iniciando um
novo Pod quando o campo réplicas de um Deployment não está atendido).
Os componentes da camada de gerenciamento podem ser executados em qualquer máquina do cluster.
Contudo, para simplificar, os scripts de configuração normalmente iniciam todos os componentes da camada
de gerenciamento na mesma máquina, e não executam containers de usuário nessa máquina.
Para o uso do Kubernetes, é necessária a instalação do:
KUBEADM
Ferramenta desenvolvida para fornecer "atalhos" de práticas recomendadas para a criação de clusters
Kubernetes.
KUBELET
Agente que é executado em cada nó no cluster. Ele garante que os containers estejam sendo executados em
um Pod.
KUBECTL
Utilitário de linha de comando usado para se comunicar com o servidor da API do cluster.
INSTALAÇÃO E CONFIGURAÇÃO DO
KUBERNETES
Existem distribuições para os principais sistemas operacionais. Optaremos pelo mais recomendado, o Linux.
Para isso, precisaremos da configuração básica de processador com mínimo de 2 CPUs, 2GB ou mais de
memória RAM por máquina, conectividade total entre as máquinas do cluster (neste caso internet – nuvem) e
nome de host exclusivo, endereço MAC e product_uuid para cada nó.
 DICA
Você pode obter o endereço MAC das interfaces de rede usando o comando ip link ou ifconfig -a. O
product_uuid pode ser verificado usando o comando sudo cat/sys/class/dmi/id/product_uuid. É muito provável
que os dispositivos de hardware tenham endereços exclusivos, embora algumas máquinas virtuais possam ter
valores idênticos.
O KUBERNETES USA ESSES VALORES PARA
IDENTIFICAR EXCLUSIVAMENTE OS NÓS NO CLUSTER.
Se esses valores não forem exclusivos para cada nó, o processo de instalação pode falhar. Se você tiver mais
de um adaptador de rede e seus componentes do Kubernetes não forem alcançáveis na rota padrão,
recomendo adicionar rota (s) IP para que os endereços de cluster do Kubernetes passem pelo adaptador
apropriado.
Certifique-se de que o módulo br_netfilter esteja carregado. Isso pode ser feito executando lsmod | grep
br_netfilter. Para carregá-lo explicitamente, chame sudo modprobe br_netfilter.
Como um requisito para o iptables do seu nó Linux ver corretamente o tráfego em ponte, você deve garantir
que net.bridge.bridge-nf-call-iptables esteja definido como 1 em sua configuração sysctl, como exemplo:
cat <<EOF | sudo tee /etc/modules-load.d/k8s.confbr_netfilter 
EOF 
 
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf 
net.bridge.bridge-nf-call-ip6tables = 1 
net.bridge.bridge-nf-call-iptables = 1 
EOF 
sudo sysctl --system
1
2
3
4
5
6
7
8
9
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Usaremos uma distribuição baseada em Debian para este exemplo. Siga os passos abaixo:
ATUALIZE O ÍNDICE DO PACOTE APT E INSTALE OS PACOTES
NECESSÁRIOS PARA USAR O REPOSITÓRIO APT DO
KUBERNETES:
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
BAIXE A CHAVE DE ASSINATURA PÚBLICA DO GOOGLE
CLOUD:
sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg
https://packages.cloud.google.com/apt/doc/apt-key.gpg
ADICIONE O REPOSITÓRIO APT DO KUBERNETES:
echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/
kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
ATUALIZE O ÍNDICE DO PACOTE APT, INSTALE KUBELET,
KUBEADM E KUBECTL E FIXE SUAS VERSÕES:
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
O kubelet agora está reiniciando a cada poucos segundos, enquanto espera em um loop de travamento que o
kubeadm diga a ele o que fazer.
VAMOS AGORA CONFIGURAR UM DRIVER CGROUP!
Tanto o tempo de execução do container quanto o kubelet têm uma propriedade chamada "driver cgroup", que
é importante para o gerenciamento de cgroups em máquinas Linux.
O kubeadm permite que você transmita uma estrutura KubeletConfiguration durante a inicialização do
kubeadm. Esse KubeletConfiguration pode incluir o campo cgroupDriver que controla o driver cgroup do
kubelet. Se não definirmos o campo cgroupDriver em KubeletConfiguration, o init do kubeadm o padronizará
como systemd.
Crie um balanceador de carga kube-apiserver com um nome que possa ser resolvido por um servidor DNS.
Em um ambiente de nuvem, você deve colocar os nós do plano de controle atrás de um balanceador de carga
de encaminhamento de TCP. Esse balanceador de carga distribui o tráfego para todos os nós do plano de
controle íntegros em sua lista de destino. A verificação de saúde de um apiserver é uma verificação de TCP
na porta em que o kube-apiserver escuta (valor padrão: 6443).
 ATENÇÃO
Não é recomendado usar um endereço IP diretamente em um ambiente de nuvem. O balanceador de carga
deve ser capaz de se comunicar com todos os nós do plano de controle na porta apiserver. Ele também deve
permitir o tráfego de entrada em sua porta de escuta. Certifique-se de que o endereço do balanceador de
carga sempre corresponda ao endereço do ControlPlaneEndpoint do kubeadm.
A configuração keepalived consiste em dois arquivos: o arquivo de configuração de serviço e um script de
verificação de saúde que será chamado periodicamente para verificar se o nó que contém o IP virtual
ainda está operacional. Presume-se que os arquivos residam em um diretório / etc / keepalived. Observe
que, no entanto, algumas distribuições do Linux podem mantê-los em outro lugar.
A seguinte configuração foi usada com sucesso com o keepalived versão 2.0.17:
! /etc/keepalived/keepalived.conf 
! Configuration File for keepalived 
global_defs { 
 router_id LVS_DEVEL 
} 
vrrp_script check_apiserver { 
 script "/etc/keepalived/check_apiserver.sh" 
 interval 3 
 weight -2 
 fall 10 
 rise 2 
} 
 
vrrp_instance VI_1 { 
 state ${STATE} 
 interface ${INTERFACE} 
 virtual_router_id ${ROUTER_ID} 
 priority ${PRIORITY} 
 authentication { 
 auth_type PASS 
 auth_pass ${AUTH_PASS} 
 } 
 virtual_ipaddress { 
 ${APISERVER_VIP} 
 } 
 track_script { 
 check_apiserver 
 } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Existem alguns marcadores de posição no estilo de variável bash para preencher:
${STATE} é MASTER para um e BACKUP para todos os outros hosts, portanto, o IP virtual será inicialmente
atribuído ao MASTER.
${INTERFACE} é a interface de rede que participa da negociação do IP virtual, por exemplo, eth0.
${ROUTER_ID} deve ser o mesmo para todos os hosts de cluster keepalived, embora único entre todos os
clusters na mesma sub-rede. Muitas distros pré-configuram seu valor para 51.
${PRIORITY} deve ser maior no nó do plano de controle do que nos backups. Portanto, 101 e 100,
respectivamente, serão suficientes.
${AUTH_PASS} deve ser o mesmo para todos os hosts de cluster keepalived, por exemplo, 42.
${APISERVER_VIP} é o endereço IP virtual negociado entre os hosts de cluster keepalived.
A configuração keepalived acima usa um script de verificação de saúde ‒ /etc/keepalived/check_apiserver.sh ‒
responsável por garantir que no nó que contém o IP virtual o servidor API esteja disponível.
Esse script pode ter a seguinte aparência:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Existem alguns marcadores de posição no estilo de variável bash para preencher:
$ {APISERVER_VIP}
É o endereço IP virtual negociado entre os hosts de cluster keepalived.
$ {APISERVER_DEST_PORT}
A porta por meio da qual o Kubernetes se comunicará com o servidor da API.configuração proxy.
A configuração do HAProxy consiste em um arquivo: o arquivo de configuração do serviço que se supõe
residir em um diretório /etc/haproxy. Observe que, no entanto, algumas distribuições do Linux podem mantê-
los em outro lugar. A seguinte configuração foi usada com sucesso com o haproxy versão 2.1.4:
#!/bin/sh 
 
errorExit() { 
 echo "*** $*" 1>&2 
 exit 1 
} 
curl --silent --max-time 2 --insecure https://localhost:${APISERVER_DEST_PORT}/ -o 
if ip addr | grep -q ${APISERVER_VIP}; then 
 curl --silent --max-time 2 --insecure https://${APISERVER_VIP}:${APISERVER_DEST
fi
1
2
3
4
5
6
7
8
9
10
# /etc/haproxy/haproxy.cfg 
#--------------------------------------------------------------------- 
# Global settings 
#--------------------------------------------------------------------- 
global 
log /dev/log local0 
log /dev/log local1 notice 
daemon 
 
#--------------------------------------------------------------------- 
# common defaults that all the 'listen' and 'backend' sections will 
# use if not designated in their block 
#--------------------------------------------------------------------- 
defaults 
mode http 
log global 
option httplog 
option dontlognull 
option http-server-close 
option forwardfor except 127.0.0.0/8 
option redispatch 
retries 1 
timeout http-request 10s
timeout queue 20s
timeout connect 5s 
timeout client 20s
timeout server 20s
timeout http-keep-alive 10s
timeout check 10s
 
#--------------------------------------------------------------------- 
# apiserver frontend which proxys to the control plane nodes 
#--------------------------------------------------------------------- 
frontend apiserver 
bind *:${APISERVER_DEST_PORT} 
mode tcp 
option tcplog 
default_backend apiserver 
 
#--------------------------------------------------------------------- 
# round robin balancing for apiserver 
#--------------------------------------------------------------------- 
backend apiserver 
option httpchk GET /healthz
http-check expect status 200 
mode tcp 
option ssl-hello-chk 
balance roundrobin 
server ${HOST1_ID} ${HOST1_ADDRESS}:${APISERVER_SRC_PORT} check 
# [...]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Novamente, existem alguns marcadores de posição no estilo de variável bash para expandir:
$ {APISERVER_DEST_PORT}: a porta por meio da qual o Kubernetes se comunicará com o servidor da API.
$ {APISERVER_SRC_PORT}: a porta usada pelas instâncias do servidorAPI.
$ {HOST1_ID}: um nome simbólico para o primeiro host do servidor API com balanceamento de carga.
$ {HOST1_ADDRESS}: um endereço resolvível (nome DNS, endereço IP) para o primeiro host do servidor API
com balanceamento de carga.
Linhas de servidor adicionais, uma para cada host de servidor API com balanceamento de carga.
Se o keepalived e haproxy forem executados nos nós do plano de controle, eles podem ser
configurados para serem executados como pods estáticos. Tudo o que é necessário aqui é colocar os
respectivos arquivos de manifesto no diretório /etc/kubernetes/manifests antes de inicializar o cluster. Durante
o processo de bootstrap, o kubelet ativará os processos para que o cluster possa usá-los durante a
inicialização. Para essa configuração, dois arquivos de manifesto precisam ser criados em /etc/ kubernetes
/manifests.
O manifesto para keepalived: /etc/kubernetes/manifests/keepalived.yaml:
apiVersion: v1 
kind: Pod 
metadata: 
creationTimestamp: null 
name: keepalived 
namespace: kube-system 
spec: 
containers: 
- image: osixia/keepalived:2.0.17 
name: keepalived 
resources: {} 
securityContext: 
capabilities: 
add: 
- NET_ADMIN 
- NET_BROADCAST 
- NET_RAW 
volumeMounts: 
- mountPath: /usr/local/etc/keepalived/keepalived.conf 
name: config 
- mountPath: /etc/keepalived/check_apiserver.sh 
name: check 
hostNetwork: true 
volumes: 
- hostPath: 
path: /etc/keepalived/keepalived.conf 
name: config 
- hostPath: 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O manifesto para haproxy, /etc/kubernetes/manifests/haproxy.yaml:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Observe que aqui, novamente, um placeholder precisa ser preenchido: ${APISERVER_DEST_PORT} precisa
conter o mesmo valor que em /etc/haproxy/haproxy.cfg (veja no código anterior). Essa combinação foi usada
com sucesso com as versões utilizadas no exemplo. Outras versões também podem funcionar ou podem
exigir alterações nos arquivos de configuração. Com os serviços ativados, agora o cluster Kubernetes pode
ser inicializado usando o kubeadm ini.
path: /etc/keepalived/check_apiserver.sh 
name: check 
status: {}
29
30
31
apiVersion: v1 
kind: Pod 
metadata: 
name: haproxy 
namespace: kube-system 
spec: 
containers: 
- image: haproxy:2.1.4 
name: haproxy 
livenessProbe: 
failureThreshold: 8 
httpGet: 
host: localhost 
path: /healthz 
port: ${APISERVER_DEST_PORT} 
scheme: HTTPS 
volumeMounts: 
- mountPath: /usr/local/etc/haproxy/haproxy.cfg 
name: haproxyconf 
readOnly: true 
hostNetwork: true 
volumes: 
- hostPath: 
path: /etc/haproxy/haproxy.cfg 
type: FileOrCreate 
name: haproxyconf 
status: {}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
AUTOMATIZANDO APLICAÇÕES COM
KUBERNETES
Para finalizar o estudo desse módulo, assista ao vídeo a seguir. Nele, apresentamos um estudo de caso de
automatização da implantação, escalonamento e gerenciamento de aplicações via Kubernetes:
VERIFICANDO O APRENDIZADO
1. O KUBERNETES PERMITE RESOLVER VÁRIOS PROBLEMAS CRÍTICOS DO USO
DE CLUSTER DE CONTAINERS, POSSIBILITANDO:.
A) Modelo de escala para máquinas virtuais de forma eficiente.
B) O emprego exclusivo para novas aplicações baseadas em nuvem.
C) Executar, de maneira eficiente e simples, o deploy de aplicações em containers Docker.
D) Que os containers sejam configurados como máquinas virtuais completas.
E) Execução de aplicações apenas em nuvens privadas e híbridas.
2. BASEADO NO CONHECIMENTO ABSORVIDO, MARQUE A ALTERNATIVA
CORRETA: SE O KEEPALIVED E HAPROXY FOREM EXECUTADOS NOS NÓS DO
PLANO DE CONTROLE:
A) Eles obrigatoriamente serão paralelos.
B) Eles podem ser configurados como strings do cluster.
C) Eles podem ser configurados para serem executados como pods estáticos.
D) Eles serão containers do cluster.
E) Eles não podem ser configurados nos nós do plano de controle.
GABARITO
1. O Kubernetes permite resolver vários problemas críticos do uso de cluster de containers,
possibilitando:.
A alternativa "C " está correta.
 
O Kubernetes possui várias características que permitem uma gestão aprimorada dos clusters de containers.
Por ser uma solução simplificada, permite a execução da solução integrada entre as soluções de containers,
desde debug a deploy.
2. Baseado no conhecimento absorvido, marque a alternativa correta: se o keepalived e haproxy forem
executados nos nós do plano de controle:
A alternativa "C " está correta.
 
Como cada nó é gerenciado de forma centralizada e tem infraestrutura compartilhada, mas possui
independências em suas imagens, todos os recursos podem ser executados como pods estáticos se forem
configurados para tal.
MÓDULO 2
 Empregar a automatização da implantação, escalonamento e gerenciamento de aplicações via
OpenShift
INTRODUÇÃO
Com as facilidades advindas do uso de tecnologia, o software está se tornando a ferramenta na qual se
constrói o futuro de nossas empresas, sejam pequenas ou grandes. No centro dessa mudança está a
evolução do próprio desenvolvimento de software.
CRIAR MODELOS DE DESENVOLVIMENTO MAIS
DINÂMICOS E ESCALONÁVEIS E AS PRÁTICAS ÁGEIS
DE DESENVOLVIMENTO SÃO AÇÕES NECESSÁRIAS
PARA SE MANTER COMPETITIVO NO MERCADO.
Os containers Linux se posicionaram no mercado como a nova base sobre a qual se deve construir conexões
entre o desenvolvimento e as operações, e aproveitar a infraestrutura para seu aplicativo, desde nuvem
pública à infraestrutura privada, tornou-se uma necessidade.
 
Imagem: Shutterstock.com
OPENSHIFT
O OpenShift é um produto de software de computador da Red Hat para implantação e gerenciamento de
softwares baseados em container. Ele é uma distribuição suportada do Kubernetes usando Docker e
ferramentas DevOps para desenvolvimento acelerado de aplicações.
Red Hat OpenShift
O Red Hat OpenShift pode ser executado em qualquer cloud, com recursos avançados para implantações em
cloud híbrida.
OpenShift Container Platform
O OpenShift Container Platform pode ser usado em infraestruturas on-premise e de cloud pública.
Isso permite uma abordagem híbrida para a implantação de aplicações como soluções autogerenciadas.
Todas as variantes da plataforma do OpenShift estão disponíveis para acelerar a produtividade do
desenvolvedor e fornecer a portabilidade de aplicações em uma base consistente na cloud híbrida.
O objetivo do OpenShift é fornecer a melhor experiência para desenvolvedores e administradores de sistemas
de desenvolvimento, implantação e execução de aplicativos.
Em outras palavras, OpenShift é uma camada além do Docker e do Kubernetes, que o torna acessível e fácil
para o desenvolvedor para criar aplicativos e uma plataforma que é um sonho para as operadoras
implantarem para cargas de trabalho de desenvolvimento e produção.
INSTALAÇÃO E CONFIGURAÇÃO DO OPENSHIFT
Neste exemplo, utilizaremos Linux baseado em Debian (Ubuntu desktop 20.4). Primeiro, vamos instalar o
Docker CE em seu sistema para executar todos os serviços OKD em containers do Docker. Por padrão, a
versão mais recente do Docker CE está disponível no repositório padrão do Ubuntu 20.04.
Você pode instalá-lo executando apenas o seguinte comando:
apt-get install docker.io -y
Depois que o Docker estiver instalado, inicie o serviço Docker e habilite-o para iniciar na inicialização com os
seguintes comandos:
systemctl start docker
systemctl enable docker
Vamos verificar o status do serviço Docker com o seguinte comando:
systemctl status docker
Você deve ver a seguinte saída:
? docker.service ‒ Docker Application Container Engine 
 Loaded: loaded (/lib/systemd/system/docker.service; disabled; vendor preset: en
1
2
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Vamos utilizar a versão V3.11.0 do OpenShift Origin. Você pode baixá-lo do repositório Git Hub usando o
seguinte comando:
wget https://github.com/openshift/origin/releases/download/v3.11.0/openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz
Assim que o download for concluído, extraia o arquivo baixado com o seguinte comando:
tar -xvzf openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz
Em seguida, altere o diretório para o diretório extraído e copie os binários kubectl e oc para o diretório
/usr/local/ bin.
cd openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit
cp oc kubectl /usr/local/bin/
A seguir, verifique a instalação do utilitário cliente OpenShift usando o seguinte comando:
oc version
Você deve ver a seguinte saída:
oc v3.11.0+0cbc58b
kubernetes v1.11.0+d4cacc0
features: Basic-Auth GSSAPI Kerberos SPNEGO
Em seguida, você precisará criar um novo arquivo daemon.json e permitir o uso do registro Insecure Docker.
nano /etc/docker/daemon.json
 Active: active (running) since Fri 2020-05-29 12:25:47 UTC; 2s ago 
TriggeredBy: ? docker.socket 
 Docs: https://docs.docker.com 
 Main PID: 48433 (dockerd) 
 Tasks: 10 
 Memory: 36.5M 
 CGroup: /system.slice/docker.service 
 ??48433 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.s
 
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.215078550Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.215139097Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.215169580Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.215721944Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.418058547Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.515158041Z" le
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.545778830Z" le
May 29 12:25:47 ubuntu2004 dockerd[4843 3]: time="2020-05-29T12:25:47.546068892Z" l
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.599029431Z" le
May 29 12:25:47 ubuntu2004 systemd[1]: Started Docker Application Container Engine.
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Adicione a seguinte linha:
{
 "insecure-registries" : [ "172.30.0.0/16" ]
}
Salve, feche o arquivo e reinicie o serviço Docker para implementar as alterações.
systemctl restart docker
Agora, inicie o cluster OpenShift Origin especificando o IP do seu sistema:
oc cluster up --public-hostname=your-server-ip
Assim que o servidor for iniciado com sucesso, você deve obter o seguinte resultado:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, faça login em seu cluster como usuário administrador com o seguinte comando:
oc login -u system:admin
Depois de fazer o login, você deve obter o seguinte resultado:
Login to server ... 
Creating initial project "myproject" ... 
Server Information ... 
OpenShift server started. 
 
The server is accessible via web console at: 
https://your-server-ip:8443
 
You are logged in as: 
User: developer 
Password: 
 
To login as administrator: 
oc login -u system:admin
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Logged into "https://your-server-ip:8443" as "system:admin" using existing credenti
You have access to the following projects and can switch between them with 'oc proj
 
default 
kube-dns 
kube-proxy 
kube-public 
kube-system 
* myproject 
openshift 
openshift-apiserver 
openshift-controller-manager 
openshift-core-operators 
1
2
3
4
5
6
7
8
9
10
11
12
13
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, mude para o projeto padrão com o seguinte comando:
oc project default
Agora, verifique o status atual do seu projeto com o seguinte comando:
oc status
Você deve obter a seguinte saída:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, faça login no OpenShift com o usuário desenvolvedor com o seguinte comando:
oc login
Será solicitado que você forneça um nome de usuário e uma senha conforme mostrado abaixo:
Authentication required for https://your-server-ip:8443 (openshift) 
Username: developer 
Password:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Forneça o nome de usuário como desenvolvedor e a senha como desenvolvedor e pressione Enter. Você deve
ver a seguinte saída:
Login successful. 
You have one project on this server: "myproject" 
openshift-infra 
openshift-node 
openshift-service-cert-signer 
openshift-web-console 
 
Using project "myproject".
14
15
16
17
18
19
In project default on server https://your-server-ip:8443 
 
svc/docker-registry - 172.30.1.1:5000 
 dc/docker-registry deploys docker.io/openshift/origin-docker-registry:v3.11 
 deployment #1 deployed 2 minutes ago - 1 pod 
 
svc/kubernetes - 172.30.0.1:443 -> 8443 
 
svc/router - 172.30.94.157 ports 80, 443, 1936 
 dc/router deploys docker.io/openshift/origin-haproxy-router:v3.11 
 deployment #1 deployed 2 minutes ago - 1 pod 
 
View details with 'oc describe /' or list everything with 'oc get all'.
1
2
3
4
5
6
7
8
9
10
11
12
13
Using project "myproject".
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para criar um novo projeto, execute o seguinte comando:
oc new-project dev --display-name="Project - Dev" --description="My Project"
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você deve ver a seguinte saída:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, abra seu navegador e digite a URL https: //seu-ip-servidor: 8443/console. Você deverá ver a página de
login do OpenShift:
Forneça seu nome de usuário e senha de desenvolvedor e clique no botão Login.
Captura de tela de login do Software OpenShift após instalação.
Você deverá ver a seguinte página:
Clique no botão Criar Projeto.
Now using project "dev" on server "https://your-server-ip:8443". 
You can add applications to this project with the 'new-app' command. For example, try: 
oc new-app centos/ruby-25-centos7~https://github.com/sclorg/ruby-ex.git to build a new e
Captura de tela de console do Software OpenShift.
Você deverá ver a seguinte página:
Forneça todas as informações necessárias e clique no botão Criar para criar um novo projeto (Create Project).
Captura de tela de console do Software OpenShift – Criar projeto.
Para implantar aplicativo no OpenShift Origin, primeiro, faça login no OpenShift com o usuário desenvolvedor
executando o seguinte comando:
oc login
Faça login com o usuário desenvolvedor conforme mostrado abaixo:
Authentication required for https://your-server-ip:8443 (openshift) 
Username: developer 
Password: 
Login successful. 
 
You have access to the following projects and can switch between them with 'oc proj
 
* dev 
my-project 
1
2
3
4
5
6
7
8
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Depois de fazer o login, mude o projeto para my-project, que você criou por meio do console da Web
OpenShift:
oc project my-project
Resultado:
Now using project "my-project" on server "https://your-server-ip:8443".
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, verifique o status do seu projeto atual com o seguinte comando:
oc status
Resultado:
In project My Project (my-project) on server https://your-server-ip:8443 
You have no services, deployment configs, or build configs. 
Run 'oc new-app' to create an application.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, marque uma imagem de aplicativo no registro do Docker Hub com o seguinte comando:
oc tag --source=docker openshift/deployment-example:v2 deployment-example:latest
Resultado:
Tag deployment-example:latest set to openshift/deployment-example:v2.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, implante um aplicativo no OpenShift com o seguinte comando:
oc new-app deployment-example
Você deve ver a seguinte saída:
myproject 
 
Using project "dev".
9
10
11
12
--> Found image da61bb2 (4 years old) in image stream "my-project/deployment-exampl
 * This imagewill be deployed in deployment config "deployment-example" 
 * Port 8080/tcp will be load balanced by service "deployment-example" 
 * Other containers can access this service through the hostname "deployment-exa
 * WARNING: Image "my-project/deployment-example:latest" runs as the 'root' user
--> Creating resources ... 
 deploymentconfig.apps.openshift.io "deployment-example" created 
1
2
3
4
5
6
7
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, verifique o status de implantação do aplicativo com o seguinte comando:
oc status
Você deve ver a seguinte saída:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para obter informações sobre seu serviço, execute o seguinte comando:
oc get svc
Resultado:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para obter informações detalhadas, execute o seguinte comando:
oc describe svc deployment-example
Resultado:
 service "deployment-example" created 
--> Success 
 Application is not exposed. You can expose services to the outside world by exe
 'oc expose svc/deployment-example' 
 Run 'oc status' to view your app.
8
9
10
11
12
In project My Project (my-project) on server https://your-server-ip:8443 
svc/deployment-example - 172.30.87.146:8080 
dc/deployment-example deploys istag/deployment-example:latest 
deployment #1 deployed 36 seconds ago - 1 pod 
2 infos identified, use 'oc status --suggest' to see details.
1
2
3
4
5
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE 
deployment-example ClusterIP 172.30.87.146 8080/TCP 1m
1
2
Name: deployment-example 
Namespace: my-project 
Labels: app=deployment-example 
Annotations: openshift.io/generated-by=OpenShiftNewApp 
Selector: app=deployment-example,deploymentconfig=deployment-example 
Type: ClusterIP 
IP: 172.30.87.146 
Port: 8080-tcp 8080/TCP 
TargetPort: 8080/TCP
Endpoints: 172.17.0.10:8080 
Session Affinity: None 
Events:
1
2
3
4
5
6
7
8
9
10
11
12
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você também pode verificar o status dos pods usando o seguinte comando:
oc get pods
Resultado:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, exponha o aplicativo para acesso externo usando o seguinte comando:
oc expose service/deployment-example
Resultado:
Resultado: 
route.route.openshift.io/deployment-example exposed
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para exibir as informações das rotas, execute o seguinte comando:
oc get routes
Você deve obter a seguinte saída:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Resultado: 
NAME READY STATUS RESTARTS AGE 
deployment-example-1-b9prf 1/1 Running 0 2m
1
2
3
NAME HOST/PORT PATH SERVICES PORT T
deployment-example deployment-example-my-project.your-server-ip.nip.io de
1
2
AUTOMATIZANDO APLICAÇÕES COM OPENSHIFT
Para finalizar o estudo desse módulo, assista ao vídeo a seguir. Nele, apresentamos um estudo de caso de
automatização da implantação, escalonamento e gerenciamento de aplicações via Openshift:
VERIFICANDO O APRENDIZADO
1. REFERENTE AO OPENSHIFT, PODEMOS AFIRMAR:
A) Que é uma solução baseada em hardware e software desenvolvida pela Red Hat.
B) Que é utilizado para o deploy de máquinas virtuais completas baseadas no Linux.
C) Que é desenvolvido para operar exclusivamente em nuvens híbridas.
D) Que é desenvolvido para implementar soluções de segurança baseada em software.
E) Que é uma distribuição suportada do Kubernetes, que emprega o Docker e ferramentas DevOps.
2. COM BASE NO QUE APRENDEMOS SOBRE OPENSHIFT, UTILIZANDO A
INTERFACE DE LINHA DE COMANDO, PODEMOS VERIFICAR:
A) O status de implantação do aplicativo.
B) Os usuários conectados na máquina virtual.
C) Informações dos processos na máquina virtual.
D) As regras de segurança no firewall nativo.
E) Informações do consumo de memória da máquina física.
GABARITO
1. Referente ao OpenShift, podemos afirmar:
A alternativa "E " está correta.
 
Openshift é uma distribuição open source, que permite a você executar aplicações e cargas de trabalho
contidas em containers orquestrados.
2. Com base no que aprendemos sobre OpenShift, utilizando a interface de linha de comando,
podemos verificar:
A alternativa "A " está correta.
 
O OpenShift permite executar diversas funcionalidades através da linha de comandos, como verificar o estado
do serviço, implantação dos aplicativos, o status dos pods, entre outros recursos.
MÓDULO 3
 Reconhecer computação acelerada por GPU com Python
 
Imagem: Shutterstock.com
INTRODUÇÃO AO PYTHON
PYTHON É UMA LINGUAGEM DE PROGRAMAÇÃO
DINÂMICA DE ALTA PRODUTIVIDADE AMPLAMENTE
USADA EM APLICATIVOS DE CIÊNCIA, ENGENHARIA E
ANÁLISE DE DADOS.
Há uma série de fatores que influenciam a popularidade do Python, incluindo sua sintaxe limpa e expressiva,
estruturas de dados padrão, biblioteca padrão abrangente, "baterias incluídas", documentação excelente,
amplo ecossistema de bibliotecas e ferramentas, disponibilidade de suporte profissional e uma grande e
aberta comunidade.
Talvez o mais importante, porém, seja a alta produtividade que uma linguagem interpretada e digitada
dinamicamente como o Python permite. Python é ágil e flexível, o que o torna uma ótima linguagem para
prototipagem rápida, mas também para construir sistemas completos.
 ATENÇÃO
Mas a maior força do Python também pode ser sua maior fraqueza: sua flexibilidade e sintaxe de alto nível
sem tipo podem resultar em baixo desempenho para programas com uso intensivo de dados e computação.
Por esse motivo, os programadores Python preocupados com a eficiência geralmente reescrevem seus loops
mais internos em C e chamam as funções C compiladas do Python.
Existem vários projetos que visam tornar essa otimização mais fácil, como o Cython, mas geralmente exigem
o aprendizado de uma nova sintaxe. Idealmente, os programadores Python gostariam de tornar seu código
Python existente mais rápido sem usar outra linguagem de programação e, naturalmente, muitos gostariam de
usar aceleradores para obter um desempenho ainda maior de seu código.
 
Imagem: Shutterstock.com
CUDA/NVIDIA
O NVIDIA CUDA É UMA PLATAFORMA DE
COMPUTAÇÃO PARALELA E UM MODELO DE
PROGRAMAÇÃO PARA SER USADO COM GPUS.
GPUS
Graphic Processing Units, unidades de processamento gráfico, em inglês.
Com ele, toda a parte “pesada” do código é executada nos diversos núcleos da placa de vídeo enquanto
apenas a parte sequencial do código é executada no processador, obtendo um ganho significativo de
performance.
javascript:void(0)
 ATENÇÃO
O uso da GPU tem custos indiretos. Se o cálculo não for pesado o suficiente, o custo (em tempo) de usar uma
GPU pode ser maior do que o ganho. Por outro lado, se o cálculo for pesado, você pode ver uma grande
melhoria na velocidade.
Vários termos importantes no tópico de programação CUDA estão listados aqui:
Host: a CPU
Device: a GPU
Host memory: a memória principal do sistema
Device memory: memória integrada em um cartão GPU
Kernel: uma função GPU lançada pelo host e executada no dispositivo
Device function: uma função GPU executada no dispositivo que só pode ser chamada a partir do dispositivo
(ou seja, a partir de um kernel ou outra função do dispositivo).
Numba oferece suporte à programação de GPU CUDA compilando diretamente um subconjunto restrito de
código Python em kernels CUDA e funções de dispositivo seguindo o modelo de execução CUDA. Kernels
escritos em Numba parecem ter acesso direto aos arrays NumPy. Matrizes NumPy são transferidas entre a
CPU e a GPU automaticamente. Numba funciona permitindo que você especifique assinaturas de tipo para
funçõesPython, o que permite a compilação em tempo de execução (isto é, “Just-in-Time” ou compilação JIT).
A capacidade do Numba de compilar código dinamicamente significa que você não abre mão da
flexibilidade do Python. Esse é um grande passo para fornecer a combinação ideal de programação de
alta produtividade e computação de alto desempenho.
 EXEMPLO
O decorador @vectorize, no código a seguir, gera uma versão compilada e vetorizada da função escalar em
tempo de execução para que possa ser usada para processar matrizes de dados em paralelo na GPU.
import numpy as np 
from numba import vectorize
 
@vectorize(['float32(float32, float32)'], target='cuda') 
def Add(a, b): 
return a + b 
 
# Initialize arrays 
N = 100000 
A = np.ones(N, dtype=np.float32) 
B = np.ones(A.shape, dtype=A.dtype) 
1
2
3
4
5
6
7
8
9
10
11
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para compilar e executar a mesma função na CPU, simplesmente mudamos o destino para 'cpu', o que
produz desempenho no nível do código C vetorizado e compilado na CPU. Essa flexibilidade ajuda a produzir
código mais reutilizável e permite desenvolver em máquinas sem GPUs.
Um dos pontos fortes da plataforma de computação paralela CUDA é a variedade de bibliotecas aceleradas
por GPUs disponíveis.
Outro projeto da equipe Numba, chamado pyculib, fornece uma interface Python para as bibliotecas CUDA
cuBLAS (álgebra linear densa), cuFFT (Fast Fourier Transform) e cuRAND (geração de número aleatório).
Muitos aplicativos serão capazes de obter uma aceleração significativa apenas usando essas bibliotecas, sem
escrever nenhum código específico da GPU. Por exemplo, o código a seguir gera um milhão de números
aleatórios uniformemente distribuídos na GPU usando o gerador de números pseudoaleatórios “XORWOW”.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
INSTALAÇÃO DO NUMBA
NUMBA É UM PROJETO DE CÓDIGO ABERTO,
LICENCIADO POR BSD, QUE SE BASEIA FORTEMENTE
NAS CAPACIDADES DO COMPILADOR LLVM.
O back-end da GPU do Numba utiliza o NVIDIA Compiler SDK baseado em LLVM. Os wrappers pyculib em
torno das bibliotecas CUDA também são de código aberto e licenciados por BSD.
C = np.empty_like(A, dtype=A.dtype) 
 
# Add arrays on GPU 
C = Add(A, B)
12
13
14
15
import numpy as np 
from pyculib import rand as curand 
 
prng = curand.PRNG(rndtype=curand.PRNG.XORWOW) 
rand = np.empty(100000) 
prng.uniform(rand) 
print rand[:10]
1
2
3
4
5
6
7
Para começar a usar o Numba, a primeira etapa é baixar e instalar a distribuição Anaconda Python, uma
"distribuição Python totalmente gratuita, pronta para empresas, para processamento de dados em grande
escala, análise preditiva e computação científica" que inclui muitos pacotes populares (Numpy, SciPy,
Matplotlib, IPython etc).
Digite o comando:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora, você pode ativar a instalação fazendo um source no arquivo ~/.bashrc: source ~/.bashrc
Assim que tiver feito isso, você será levado ao ambiente de programação padrão de base do Anaconda, e seu
prompt de comando mudará para o seguinte: (base) summy@ubuntu:~$
Embora o Anaconda venha com esse ambiente de programação padrão de base, você deve criar
ambientes separados para seus programas e mantê-los isolados um do outro. Você pode, ainda,
verificar sua instalação fazendo o uso do comando conda, por exemplo, com list:
(base) summy@ubuntu:~$ conda list
Você receberá a saída de todos os pacotes disponíveis através da instalação do Anaconda.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Agora que o Anaconda está instalado, podemos seguir em frente para a configuração dos ambientes dele.
 ATENÇÃO
Os ambientes virtuais do Anaconda lhe permitem manter projetos organizados pelas versões do Python e
pelos pacotes necessários. Para cada ambiente do Anaconda que você configurar, especifique qual versão do
Python usar e mantenha todos os arquivos de programação relacionados dentro desse diretório.
Primeiro, podemos verificar quais versões do Python estão disponíveis para que possamos usar: (base)
summy@ubuntu:~$ conda search "^python$"
apt-get install libgl1-mesa-glx libegl1-mesa libxrandr2 libxrandr2 libxss1 libxcursor1 l
# packages in environment at /home/sammy/anaconda3: 
# Name Version Build Channel 
_ipyw_jlab_nb_ext_conf 0.1.0 py37_0 
_libgcc_mutex 0.1 main 
alabaster 0.7.12 py37_0 
anaconda 2020.02 py37_0 
...
1
2
3
4
5
6
7
VAMOS CRIAR UM AMBIENTE USANDO A VERSÃO MAIS
RECENTE DO PYTHON 3.
Podemos conseguir isso atribuindo a versão 3 ao argumento python. Vamos chamar o ambiente de my_env,
mas você pode usar um nome mais descritivo para o ambiente, especialmente se estiver usando ambientes
para acessar mais de uma versão do Python.
(base) summy@ubuntu:~$ conda create --name my_env python=3
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você receberá uma saída com informações sobre o que está baixado e quais pacotes serão instalados e, em
seguida, será solicitado a prosseguir com y ou n. Assim que concordar, digite y.
O utilitário conda agora irá obter os pacotes para o ambiente e informá-lo assim que estiver concluído. Você
pode ativar seu novo ambiente digitando o seguinte:
(base) summy@ubuntu:~$ conda activate my_env
Com seu ambiente ativado, seu prefixo do prompt de comando irá refletir que você não está mais no ambiente
base, mas no novo ambiente que acabou de criar.
(my_env) summy@ubuntu:~$
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Dentro do ambiente, você pode verificar se está usando a versão do Python que tinha intenção de usar:
(my_env) summy@ubuntu:~$ python –version
 RESPOSTA
Python 3.8.2
Quando estiver pronto para desativar seu ambiente do Anaconda, você pode fazer isso digitando: (my_env)
summy@ubuntu:~$ conda deactivate
Observe que pode substituir a palavra source por . para obter os mesmos resultados. Para focar em uma
versão mais específica do Python, você pode passar uma versão específica para o argumento python,
como 3.5, por exemplo:
(base) summy@ubuntu:~$ conda create -n my_env35 python=3.5
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você pode inspecionar todos os ambientes que configurou com este comando:
(base) summy@ubuntu:~$ conda info –envs 
 
 
# conda environments: 
# 
base * /home/sammy/anaconda3 
my_env /home/sammy/anaconda3/envs/my_env 
my_env35 /home/sammy/anaconda3/envs/my_env35
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O asterisco indica o ambiente ativo atual. Cada ambiente que você criar com o conda create virá com vários
pacotes padrão:
_libgcc_mutex
ca-certificates
certifi
libedit
libffi
libgcc-ng
libstdcxx-ng
ncurses
openssl
pip
python
readline
setuptools
sqlite
tk
wheel
xz
zlib
Você pode acrescentar pacotes adicionais, como o Numpy, por exemplo, com o seguinte comando:
(base) summy@ubuntu:~$ conda install --name my_env35 numpy
Se você já sabe que gostaria de um ambiente Numpy após a criação, pode concentrá-lo em seu comando
conda create:
(base) summy@ubuntu:~$ conda create --name my_env python=3 numpy
Se você não estiver mais trabalhando em um projeto específico e não tiver mais necessidade do ambiente
associado, pode removê-lo. Para fazer isso, digite o seguinte:
(base) summy@ubuntu:~$ conda remove --name my_env35 --all
 ATENÇÃO
Agora, quando você digitar o comando conda info --envs, o ambiente que removeu não será mais listado.
Você deve garantir regularmente que o Anaconda esteja atualizado para que você esteja trabalhando com
todas as versões mais recentes do pacote. Para fazer isso, deve primeiro atualizar o utilitárioconda: (base)
summy@ubuntu:~$ conda update conda
Quando solicitado a fazer isso, digite y para continuar com a atualização. Assim que a atualização do conda
estiver concluída, você pode atualizar a distribuição do Anaconda:
(base) summy@ubuntu:~$ conda update anaconda
 ATENÇÃO
Novamente, quando solicitado a fazer isso, digite y para continuar. Isso garantirá que você esteja usando as
versões mais recentes do conda e do Anaconda.
Depois de instalar o Anaconda, instale os pacotes CUDA necessários digitando:
conda install numba cudatoolkit pyculib
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O Anaconda (anteriormente Continuum Analytics) reconheceu que alcançar grandes acelerações em alguns
cálculos requer uma interface de programação mais expressiva com controle mais detalhado sobre o
paralelismo do que as bibliotecas e a vetorização automática de loop podem fornecer.
Portanto, o Numba possui outro conjunto importante de recursos que constitui o que é conhecido não
oficialmente como “CUDA Python”.
Numba expõe o modelo de programação CUDA, assim como em CUDA C / C ++, mas usando a sintaxe
Python pura, para que os programadores possam criar kernels paralelos personalizados e ajustados sem
deixar o conforto e as vantagens do Python para trás. O CUDA JIT da Numba (disponível via decorador ou
chamada de função) compila funções CUDA Python em tempo de execução, especializando-as para os tipos
que você usa, e sua API CUDA Python fornece controle explícito sobre transferências de dados e fluxos
CUDA, entre outros recursos.
O exemplo de código a seguir demonstra isso com um kernel de conjunto Mandelbrot simples. Observe
que a função mandel_kernel usa as estruturas cuda.threadIdx, cuda.blockIdx, cuda.blockDim e cuda.gridDim
fornecidas por Numba para calcular os índices globais de pixel X e Y para o segmento atual. Como em outras
linguagens CUDA, lançamos o kernel inserindo uma "configuração de execução" (linguagem CUDA para o
número de threads e blocos de threads a serem usados para executar o kernel) entre colchetes, entre o nome
da função e a lista de argumentos: mandel_kernel [griddim, blockdim] (- 2.0, 1.0, -1.0, 1.0, d_image, 20). Você
também pode ver o uso das funções de API to_host e to_device para copiar dados de e para a GPU.
@cuda.jit 
def mandel_kernel(min_x, max_x, min_y, max_y, image, iters): 
 height = image.shape[0]
 width = image.shape[1] 
 
 pixel_size_x = (max_x - min_x) / width 
 pixel_size_y = (max_y - min_y) / height 
 
 startX = cuda.blockDim.x * cuda.blockIdx.x + cuda.threadIdx.x 
 startY = cuda.blockDim.y * cuda.blockIdx.y + cuda.threadIdx.y 
 gridX = cuda.gridDim.x * cuda.blockDim.x; 
 gridY = cuda.gridDim.y * cuda.blockDim.y; 
 
 for x in range(startX, width, gridX): 
 real = min_x + x * pixel_size_x 
 for y in range(startY, height, gridY): 
 imag = min_y + y * pixel_size_y 
 image[y, x] = mandel(real, imag, iters) 
 
 gimage = np.zeros((1024, 1536), dtype = np.uint8) 
 blockdim = (32, 8) 
 griddim = (32,16) 
 
 start = timer() 
 d_image = cuda.to_device(gimage) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 Atenção! Para visualização completa do código utilize a rolagem horizontal
 SAIBA MAIS
Em um servidor com uma GPU NVIDIA Tesla P100 e uma CPU Intel Xeon E5-2698 v3, este código CUDA
Python Mandelbrot é executado quase 1700 vezes mais rápido do que a versão Python pura. 1700x pode
parecer uma aceleração irreal, mas tenha em mente que estamos comparando o código Python compilado,
paralelo e acelerado por GPU ao código Python interpretado de thread único na CPU.
COMPUTAÇÃO ACELERADA COM PYTHON
No vídeo a seguir, abordamos o conceito de computação acelerada com Python utilizando CUDA/Nvidia:
 mandel_kernel[griddim, blockdim](-2.0, 1.0, -1.0, 1.0, d_image, 20) 
 d_image.to_host() 
 dt = timer() - start 
 
 print "Mandelbrot created on GPU in %f s" % dt 
 
 imshow(gimage)
25
26
27
28
29
30
31
32
VERIFICANDO O APRENDIZADO
1. MARQUE A ALTERNATIVA QUE CORRESPONDE AO PYTHON:
A) Possui biblioteca padrão abrangente.
B) Exige sintaxe detalhada e formal.
C) Desenvolvido em Javascript e C++.
D) Sistema Operacional baseado em Linux.
E) Controladora de containers.
2. COM BASE NO QUE APRENDEMOS, SÃO TERMOS USADOS NO TÓPICO DA
PROGRAMAÇÃO CUDA, EXCETO:
A) Host
B) Kernel
C) Device CPU
D) Device memory
E) Device function
GABARITO
1. Marque a alternativa que corresponde ao Python:
A alternativa "A " está correta.
 
O Python é uma linguagem de programação com extenso uso, com uma grande comunidade de contribuintes
e com extensa disponibilidade de artigos, informações e bibliotecas.
2. Com base no que aprendemos, são termos usados no tópico da programação CUDA, exceto:
A alternativa "C " está correta.
 
A programação acelerada por GPU associa os termos da placa de vídeo como device, associando a ela a
nomenclatura conforme aplicação. Não existe associação da device à CPU do computador.
MÓDULO 4
 Descrever Docker Swarm
INTRODUÇÃO AO DOCKER
DOCKER É UMA PLATAFORMA ABERTA PARA
DESENVOLVIMENTO, ENVIO E EXECUÇÃO DE
APLICATIVOS.
O Docker permite que você separe seus aplicativos de sua infraestrutura para que possa entregar software
rapidamente. Com o Docker, é possível gerenciar sua infraestrutura da mesma forma que gerencia seus
aplicativos. Tirando proveito das metodologias do Docker para envio, teste e implantação de código
rapidamente, você pode reduzir significativamente o atraso entre escrever o código e executá-lo na produção.
INSTALAÇÃO DO DOCKER
Antes de instalar o Docker Engine pela primeira vez em uma nova máquina host, você precisa configurar o
repositório do Docker. Depois disso, pode instalar e atualizar o Docker a partir do repositório. Atualize o índice
do pacote apt e instale os pacotes para permitir que o apt use um repositório sobre HTTPS:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Adicione a chave GPG oficial do Docker:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Use o seguinte comando para configurar o repositório estável. Para adicionar o repositório noturno ou de
teste, adicione a palavra nightly ou test (ou ambos) após a palavra stable nos comandos abaixo:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Atualize o índice do pacote apt e instale a versão mais recente do Docker Engine e containerd ou vá para a
próxima etapa para instalar uma versão específica:
$ sudo apt-get update 
$ sudo apt-get install docker-ce docker-ce-cli containerd.io
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para instalar uma versão específica do Docker Engine, liste as versões disponíveis no repo, selecione e
instale uma. Liste as versões disponíveis em seu repo:
$ apt-cache madison docker-ce
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Instale uma versão específica usando a string de versão da segunda coluna:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/s
$ echo \ 
 "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://d
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/nul
$ sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STRING> contain
$sudo apt-get update 
 
$ sudo apt-get install \ 
 apt-transport-https \ 
 ca-certificates \ 
 curl \ 
 gnupg \ 
 lsb-release
1
2
3
4
5
6
7
8
Verifique se o Docker Engine está instalado corretamente executando a imagem hello-world:
$ sudo docker run hello-world
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Este comando baixa uma imagem de teste e a executa em um container. Quando o container é executado, ele
imprime uma mensagem informativa e sai. O Docker Engine está instalado em execução. O grupo dockeré
criado, mas nenhum usuário é adicionado a ele.
Você precisa usar sudo para executar comandos do Docker.
Continue a pós-instalação do Linux para permitir que usuários sem privilégios executem comandos do Docker
e para outras etapas de configuração opcionais.
CONFIGURANDO A CLI DO AZURE
Quando a CLI do Azure for configurada, você precisará fazer login. Você será solicitado a inserir um código
em seu navegador. Depois disso, o comando continuará:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O comando deve retornar um json semelhante a este:
[ 
 { 
 "cloudName": "AzureCloud", 
 "id": "xxxxxxx", 
 "isDefault": true, 
 "name": "Free Trial", 
 "state": "Enabled", 
 "tenantId": "xxxxxx", 
 "user": { 
 "name": "xxxxx",
 "type": "user" 
 } 
 } 
]
 Atenção! Para visualização completa do código utilize a rolagem horizontal
az login 
 
To sign in, use a web browser to open the page https://aka.ms/devicelogin and enter the 
Depois de fazer login, você pode executar comandos az, como o az account show mostrando algumas
informações da conta:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
DOCKER SWARM NA MICROSOFT AZURE
O método que usaremos para configurar o Docker Swarm no Azure é usando um modelo do Azure que é
criado pela equipe do Docker (e não pela Microsoft). Ao usar este tema, poderemos utilizar as versões mais
recentes do Docker/Swarm, ao mesmo tempo em que nos integramos perfeitamente ao Microsoft Azure
Cloud.
 ATENÇÃO
Antes de começarmos com o Docker para Azure, devemos criar uma entidade de serviço em nosso Active
Directory. Pense nisso como um usuário que tem permissões para fazer coisas de infraestrutura de baixo
nível, como escalar suas VMs, atualizar suas regras de balanceador de carga. Operações necessárias para
uma solução dinâmica Docker Swarm no Azure.
Existem duas maneiras de criar um principal de serviço:
Por meio de um container do docker, conforme descrito no guia do Docker para Azure.

Por meio do Portal do Azure (no módulo Active Directory, criando um registro de aplicativo).
{ 
 "environmentName": "AzureCloud", 
 "id": "c1ddf2e6-8c94-490c-a1f0-e54d24f76323", 
 "isDefault": true, 
 "name": "Free Trial", 
 "state": "Enabled", 
 "tenantId": "930763d2-b2ba-4d30-bd7b-908bbf4ac227", 
 "user": { 
 "name": "davy.dewaele@ixor.be", 
 "type": "user" 
 } 
}
1
2
3
4
5
6
7
8
9
10
11
12
Vamos usar a linha de comando e ativar o container do docker, que leva 3 argumentos:
O nome principal do serviço
O nome do grupo de recursos
A Região Azure
O comando é parecido com este:
docker run -ti docker4x/create-sp-azure sp1 swarm1 westeurope
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Isso vai criar:
Um aplicativo do Active Directory que permite que o swarm dimensione/exponha portas
Um ServicePrincipal (com um ID de aplicativo e segredo de aplicativo)
Um grupo de recursos
Você precisará fazer o login através do seu navegador para iniciar a CLI. Depois disso, você receberá um bom
resumo no final.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você pode olhar no portal para ver se a entidade de serviço foi criada.
 
 Captura de tela do portal Microsoft Azure após iniciar CLI.
Your access credentials ================================================== 
AD ServicePrincipal App ID: 98369e6d-9d9c-419d-86fa-075ce0cdcc83 
AD ServicePrincipal App Secret: FITLMrNLMpokhi3YvZPbm7y36FDsUkXn 
AD ServicePrincipal Tenant ID: 930763d2-b2ba-4d30-bd7b-908bbf4ac227 
Resource Group Name: swarm1 
Resource Group Location: westeurope
1
2
3
4
5
6
O APPID E O APPSECRET SERÃO NECESSÁRIOS AO
EXECUTAR O MODELO DOCKER.
Existem duas maneiras de instalar a oferta Docker para Azure, por meio da IU do Azure, seguindo o link do
modelo do Docker para Azure, e por meio da CLI do Azure, permitindo automatizar ainda mais a implantação.
Abordaremos as duas opções.
INSTALANDO O DOCKER PARA AZURE USANDO A IU DO AZURE.
Seguiremos as etapas no guia do Docker para Azure. Ao clicar no botão para instalar o Docker para Azure,
você será redirecionado para o portal do Azure, onde será solicitado a preencher algumas propriedades como:
AppID;
AppSecret;
Public SSH Key;
Number + Type of workers;
Number + Type of managers.
 
 Captura de tela do portal do Microsoft Azure após instalação.
A criação de toda a pilha levará alguns minutos. Você pode monitorar o progresso na janela de notificações.
Quando a implantação for concluída, você será redirecionado para a seção de visão geral do grupo de
recursos. Aqui você encontrará todos os recursos que foram criados usando o modelo Docker para Azure.
 
 Captura de tela do portal Microsoft Azure visão de recursos.
O modelo criou vários recursos, incluindo:
IP público para o balanceador de carga (para expor seus aplicativos)
IP público para o balanceador de carga SSH (para SSH-ing em seu gerenciador de swarm)
Conjuntos de escala de VM, capazes de gerar máquinas virtuais
Balanceadores de carga
Redes virtuais
Contas de armazenamento
VOCÊ TAMBÉM PODE INSTALAR O DOCKER PARA
AZURE USANDO A CLI.
Novamente, certifique-se de ter criado o principal de serviço:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, crie a implantação:
docker run -ti docker4x/create-sp-azure docker-for-azure-sp docker-for-azure-rg centralu
az group deployment create --name docker-swarm-deployment --resource-group docker-for-az
Please provide string value for 'adServicePrincipalAppID' (? for help): xxxxxx 
Please provide securestring value for 'adServicePrincipalAppSecret' (? for help): xxxxxx
Please provide string value for 'sshPublicKey' (? for help): ssh-rsa xxxxxx
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você precisará fornecer:
adServicePrincipalAppID;
adServicePrincipalAppSecret;
chave SSH pública.
Você pode utilizar um arquivo de parâmetros como este para uma instalação silenciosa completa de toda a
pilha sem que ela solicite nada:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
{ 
 "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentPa
 "contentVersion": "1.0.0.0", 
 "parameters": { 
 "adServicePrincipalAppID": { 
 "value": "2069aee6-5520-4790-8cc1-ae4e745e01bc" 
 }, 
 "adServicePrincipalAppSecret": { 
 "value": "34279fd7-1fd5-451b-95fe-cb8f84f2615b" 
 }, 
 "enableSystemPrune": { 
 "value": "no" 
 }, 
 "managerCount": { 
 "value": 1 
 }, 
 "managerVMSize": { 
 "value": "Standard_D1_v2" 
 }, 
 "sshPublicKey": { 
 "value": "ssh-rsa xxxxxx" 
 }, 
 "swarmName": { 
 "value": "dockerswarm" 
 }, 
 "workerCount": { 
 "value": 2 
 }, 
 "workerVMSize": { 
 "value": "Standard_D1_v2" 
 } 
 } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Para tanto, execute o seguinte comando:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Para saber como se conectar ao gerenciador de swarm, você precisa ir para o modelo de implantação do
cluster de swarm (por meio do grupo de recursos):
 
 Captura de tela do portal Microsoft Azure – grupo de recursos.
Ao clicar no modelo, você encontrará duas propriedades interessantes:
DefaultDNSTargets;
SSH targets.
 
 Captura de tela do portal Microsoft Azure – Default DNS.
docker run -ti docker4x/create-sp-azure docker-for-azure-sp docker-for-azure-rg centralu
O DefaultDNSTargets dá acesso ao cluster swarm. Todos os aplicativos que forem iniciados lá serão
disponibilizados naquele IP. Os serviços Docker Swarm que expõem uma porta verão sua porta exposta por
meio do balanceador de carga externo nesse IP. Os SSH Targets mostrarão como você pode acessar o cluster
swarm via SSH.
 
 Captura de tela do portal Microsoft Azure ‒ DefaultDNSTargets.
Por padrão, o gerenciador Swarm escutará naporta 50000. Para SSH no gerenciador, execute este comando:
ssh -A docker@52.174.20.207 -p 50000
 Atenção! Para visualização completa do código utilize a rolagem horizontal
 ATENÇÃO
Observe como usamos o encaminhamento de chave do Agente SSH. Isso vai se tornar importante mais tarde,
quando quisermos fazer login nos nós de trabalho.
Mas, uma vez que estamos no gerenciador de swarm, podemos executar os comandos docker conhecidos:
Docker version
Welcome to Docker! 
 
swarm-manager000000:~$ docker -v 
Docker version 17.06.0-ce, build 02c1d87
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Docker containers
swarm-manager000000:~$ docker ps 
CONTAINER ID IMAGE COMMAND 
1891668c2a41 docker4x/l4controller-azure:17.06.0-ce-azure2 "loadbalancer r
5069b42130ea docker4x/meta-azure:17.06.0-ce-azure2 "metaserver -ia
1e55147b18b1 docker4x/guide-azure:17.06.0-ce-azure2 "/entry.sh" 
1
2
3
4
 Atenção! Para visualização completa do código utilize a rolagem horizontal
See the swarm nodes
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Caso esteja vendo algo assim:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Você sabe que algo está errado, e um bom lugar para começar é verificar os logs do container docker init-
azure (veja abaixo). Normalmente, os erros surgem ao usar o responsável pelo serviço errado. Em caso
de erros, você pode excluir o grupo e começar de novo:
az group delete --name docker-for-azure-test-rg 
Are you sure you want to perform this operation? (y/n): y 
| Running ..
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Problemas de depuração. Em termos de depuração, o comando a seguir fornecerá alguns insights sobre o
que aconteceu quando o Azure estava configurando o cluster swarm.
docker logs $(docker ps -a | grep init-azure | cut -d' ' -f1)
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Conecte-se a um trabalhador. Para se conectar aos trabalhadores de que você precisa:
Faça login no gerenciador com encaminhamento do Agente SSH (switch -A);
Descubra o domínio de pesquisa DNS da instalação (procure em /etc/resolv.conf);
warm-manager000000:~$ docker node ls 
Error response from daemon: This node is not a swarm manager. Use "docker swarm init" or
79db940f7e63 docker4x/logger-azure:17.06.0-ce-azure2 "python /server
456a2a2df8fd docker4x/init-azure:17.06.0-ce-azure2 "/entry.sh" 
20c56749ed4e docker4x/agent-azure:17.06.0-ce-azure2 "supervisord --
5
6
7
8
swarm-manager000000:~$ docker node ls 
ID HOSTNAME STATUS AVAILABILIT
r62i4rpvp1kmxlf7goamkbsy8 swarm-worker000000 Ready Active 
rwk7lhwndmg86m4rkaa3upwmu * swarm-manager000000 Ready Active 
vtvh17ce0qsc37ecy8k5dng11 swarm-worker000001 Ready Active
1
2
3
4
5
SSH nas máquinas.
 Atenção! Para visualização completa do código utilize a rolagem horizontal
UM DOS ITENS CRIADOS DURANTE A DISTRIBUIÇÃO
DO DOCKER PARA AZURE É UM BALANCEADOR DE
CARGA EXTERNO.
O balanceador de carga externo possui um IP que pode ser acessado da internet. Assim que começarmos a
adicionar serviços de enxame que expõem uma porta, você notará que essas portas também serão
exportadas no balanceador de carga.
 
 Captura de tela do portal Microsoft Azure – Balanceador de carga externa.
Serviços de lançamento. Inicialmente, criaremos nossa rede:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
E, então, inicie um serviço:
docker service create --network cnet --name nginx1 -p 80:80 nginx
swarm-manager000000:~$ ssh docker@swarm-worker000001.oqzhphocr3cublz2fzkpyrwd5c.ax.inter
docker network create \ 
 --driver overlay \ 
 --subnet 10.0.9.0/24 \ 
 --gateway 10.0.9.99 \ 
 cnet
1
2
3
4
5
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Observe como agora vemos uma regra associada ao nosso balanceador de carga:
 
 Captura de tela do portal Microsoft Azure – Balanceador externo.
E, se olharmos mais de perto, veremos de fato a regra do balanceador de carga que encaminhará o tráfego
externo em nosso balanceador de carga na porta 00 para nosso serviço Swarm (também em execução na
porta 80).
 
 Captura de tela do portal Microsoft Azure – Balanceador externo.
Esses serviços ficarão disponíveis imediatamente por meio do balanceador de carga:
docker service create --network cnet --name nginx2 -p 81:80 nginx 
docker service create --network cnet --name nginx3 -p 82:80 nginx 
docker service create --network cnet --name nginx4 -p 0:80 nginx 
docker service create --network cnet --name nginx5 nginx 
 
docker service scale nginx3=10
1
2
3
4
5
6
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Com todos esses containers sendo gerados, é importante ser capaz de ler arquivos de log para obter
melhores insights sobre seus containers. Você provavelmente está familiarizado com o comando docker
logs para ler os logs vindos de um container, mas no Azure, ao tentar olhar os logs do docker, você receberá o
seguinte erro:
swarm-worker000001:~$ docker logs -f d7e9d806f872 
Error response from daemon: configured logging driver does not support reading
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O Docker para Azure usa um driver de log diferente e usa um container logger-azure para garantir que todos
os logs de todos os containers sejam centralizados. Se você observar o grupo de recursos usados para
criar o docker swarm, verá uma conta de armazenamento chamada on6fwskwzstvqlogs.
 
 Captura de tela do portal Microsoft Azure – Driver log.
Quando você se conecta a esta conta de armazenamento, o Azure mostra os cmds para se conectar a ela a
partir do Windows ou Linux.
 
 Captura de tela do portal Microsoft Azure – servidor de arquivos – pasta LOG.
No Linux, você pode montar a pasta de logs em um servidor virtual na mesma região (não funciona nas VMs
Docker Swarm).
 
 Captura de tela do portal Microsoft Azure – servidor de arquivos – pasta LOG.
Para montar a pasta de registro, basta executar os seguintes comandos:
 Atenção! Para visualização completa do código utilize a rolagem horizontal
mkdir -p /var/logs/docker 
sudo mount -t cifs //le66r7q7iia3klogs.file.core.windows.net/docker4azurelogs /var/
1
2
DOCKER SWARM
Chegamos ao fim de mais um módulo. E, para finalizar os estudos, apresentamos o conceito de Docker
Swarm, incluindo estudo de caso em Microsoft Azure, no vídeo a seguir:
VERIFICANDO O APRENDIZADO
1. MARQUE A ALTERNATIVA CORRETA SOBRE DOCKER:
A) Docker é uma plataforma criada pela Red Hat para desenvolvimento, envio e execução de aplicativos.
B) Docker é uma plataforma aberta para separar os componentes dos aplicativos em containers diferentes.
C) Docker é uma plataforma da Microsoft para desenvolvimento, envio e execução de aplicativos.
D) Docker é uma plataforma para armazenagem cloud da AWS.
E) Docker é uma plataforma aberta para desenvolvimento, envio e execução de aplicativos.
2. EM RELAÇÃO À INSTALAÇÃO DO DOCKER NA AZURE, SÃO PROPRIEDADES DE
INSTALAÇÃO A SEREM PREENCHIDAS, EXCETO:
A) AppID
B) App Secret
C) Public SSH Key
D) Number + Type of workers
E) Number + Type of clusters
GABARITO
1. Marque a alternativa correta sobre Docker:
A alternativa "E " está correta.
 
Docker é um conjunto de produtos de plataforma como serviço que usam virtualização de nível de sistema
operacional para entregar software em pacotes chamados containers. Os containers são isolados uns dos
outros e agrupam seus próprios softwares, bibliotecas e arquivos de configuração.
2. Em relação à instalação do Docker na Azure, são propriedades de instalação a serem preenchidas,exceto:
A alternativa "E " está correta.
 
Dentro das propriedades do Docker, todas as nomenclaturas seguem um padrão dos serviços que executam.
Todos os campos referentes ao Docker são restritos a nomes que descrevem as atividades relacionadas.
CONCLUSÃO
CONSIDERAÇÕES FINAIS
Estudamos conceitos importantes sobre automatização da implantação, escalonamento e gerenciamento de
aplicações via Kubernetes e via OpenShift, incluindo estudo de caso na nuvem em ambos. Compreendemos
computação acelerada por GPU com Python com CUDA/NVIDIA e finalizamos com a aprendizagem sobre
Docker Swarm, com estudo de caso em Microsoft Azure.
AVALIAÇÃO DO TEMA:
REFERÊNCIAS
ARUNDEL, J.; DOMINGUS, J. DevOps nativo de nuvem com Kubernetes ‒ Como construir, implantar e
escalar aplicações modernas na nuvem. São Paulo: Novatec, 2019.
BLOKDYK, G. OpenShift ‒ A Complete Guide. Brisbane: Emereo Pty Ltd, 2019.
FARBER, R. Cuda: Application Design and Development. Amsterdam: Morgan Kaufmann Publishers, 2011.
FARCIC, V. The DevOps 2.1 Toolkit: Docker Swarm. Birmingham: Packt Publishing, 2017.
EXPLORE+
Para saber mais sobre os assuntos discutidos neste conteúdo, pesquise na internet e assista aos vídeos
sobre:
Containers computacionais;
Kubernetes;
CUDA/NVIDIA;
DOCKER.
Amplie seus conhecimentos sobre Kubernetes no site edX da Linux Foundation, e sobre OpenShift, no site
RedHat OpenShift.
CONTEUDISTA
Marcelo dos Santos Machado
 CURRÍCULO LATTES
javascript:void(0);