Tema 4 Tópicos Avançados em Computação Distribuída e Paralela

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:
 Atenção! Para visualizaçãocompleta 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
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf 
br_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
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:
 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.
! /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
${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_DES
if ip addr | grep -q ${APISERVER_VIP}; then 
 curl --silent --max-time 2 --insecure https://${APISERVER_VIP}:${AP
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 
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
 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 servidor API.
$ {HOST1_ID}: um nome simbólico para o primeiro host do servidor API com balanceamento
de carga.
$ {HOST1_ADDRESS}: um endereçoresolví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:
mode tcp 
option ssl-hello-chk 
balance roundrobin 
server ${HOST1_ID} ${HOST1_ADDRESS}:${APISERVER_SRC_PORT} check 
# [...]
46
47
48
49
50
apiVersion: v1 
kind: Pod 
metadata: 
creationTimestamp: null 
name: keepalived 
namespace: kube-system 
spec: 
containers: 
- image: osixia/keepalived:2.0.17 
name: keepalived 
resources: {} 
1
2
3
4
5
6
7
8
9
10
11
 Atenção! Para visualização completa do código utilize a rolagem horizontal
O manifesto para haproxy, /etc/kubernetes/manifests/haproxy.yaml:
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: 
path: /etc/keepalived/check_apiserver.sh 
name: check 
status: {}
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 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.
AUTOMATIZANDO APLICAÇÕES COM
KUBERNETES
hostNetwork: true 
volumes: 
- hostPath: 
path: /etc/haproxy/haproxy.cfg 
type: FileOrCreate 
name: haproxyconf 
status: {}
21
22
23
24
25
26
27
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:
 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
? docker.service ‒ Docker Application Container Engine 
 Loaded: loaded (/lib/systemd/system/docker.service; disabled; vendo
 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/
 
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.21
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.21
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.21
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.21
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.41
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.51
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.54
May 29 12:25:47 ubuntu2004 dockerd[4843 3]: time="2020-05-29T12:25:47.5
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-29T12:25:47.59
May 29 12:25:47 ubuntu2004 systemd[1]: Started Docker Application Conta
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
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:
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: 
 
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
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:
 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:
To login as administrator: 
oc login -u system:admin
14
Logged into "https://your-server-ip:8443" as "system:admin" using exist
You have access to the following projects and can switch between them w
 
default 
kube-dns 
kube-proxy 
kube-public 
kube-system 
* myproject 
openshift 
openshift-apiserver 
openshift-controller-manager 
openshift-core-operators 
openshift-infra 
openshift-node 
openshift-service-cert-signer 
openshift-web-console 
 
Using project "myproject".
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In project default on server https://your-server-ip:8443 
 
svc/docker-registry - 172.30.1.1:5000 
1
2
3
 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" 
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:
 dc/docker-registry deploys docker.io/openshift/origin-docker-regist
 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'
4
5
6
7
8
9
10
11
12
13
Now using project "dev" on server "https://your-server-ip:8443". 
You can add applications to this project with the 'new-app' command. For exa
oc new-app centos/ruby-25-centos7~https://github.com/sclorg/ruby-ex.git to b
 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.
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:
 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:
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 w
 
* dev 
my-project 
myproject 
 
Using project "dev".
1
2
3
4
5
6
7
8
9
10
11
12
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:
 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çãocompleta do código utilize a rolagem horizontal
Para obter informações sobre seu serviço, execute o seguinte comando:
oc get svc
Resultado:
--> Found image da61bb2 (4 years old) in image stream "my-project/deplo
 * This image will be deployed in deployment config "deployment-exam
 * Port 8080/tcp will be load balanced by service "deployment-exampl
 * Other containers can access this service through the hostname "de
 * WARNING: Image "my-project/deployment-example:latest" runs as the
--> Creating resources ... 
 deploymentconfig.apps.openshift.io "deployment-example" created 
 service "deployment-example" created 
--> Success 
 Application is not exposed. You can expose services to the outside 
 'oc expose svc/deployment-example' 
 Run 'oc status' to view your app.
1
2
3
4
5
6
7
8
9
10
11
12
In project My Project (my-project) on server https://your-server-ip:844
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
 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:
 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:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) 
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-e
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
Resultado: 
NAME READY STATUS RESTARTS AGE 
deployment-example-1-b9prf 1/1 Running 0 2m
1
2
3
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
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
NAME HOST/PORT PATH SERVICES 
deployment-example deployment-example-my-project.your-server-ip.nip.i
1
2
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ções Python, 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
1
2
 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
 
@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) 
C = np.empty_like(A, dtype=A.dtype) 
 
# Add arrays on GPU 
C = Add(A, B)
3
4
5
6
7
8
9
10
11
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
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.
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:
apt-get install libgl1-mesa-glx libegl1-mesa libxrandr2 libxrandr2 libxss1 l
 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$"
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
# 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
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ário conda: (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] 
 
1
2
3
4
5
 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.
 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) 
 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)
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
COMPUTAÇÃO ACELERADA COM PYTHON
No vídeo a seguir, abordamos o conceito de computação acelerada com Python utilizando
CUDA/Nvidia:
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:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearm
 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:
$ echo \ 
 "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gp
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.lis
 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
$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
 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:
$ sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cli=<VERSION_STR
 Atenção! Para visualização completa do código utilize a rolagem horizontal
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á:
az login 
 
To sign in, use a web browser to open the page https://aka.ms/devicelogin an
 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
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.
{ 
 "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
 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).
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.
Your access credentials ===============================================
AD ServicePrincipal App ID: 98369e6d-9d9c-419d-86fa-075ce0cdcc83 
AD ServicePrincipal App Secret: FITLMrNLMpokhi3YvZPbm7y36FDsUkXn 
1
2
3
 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.
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.
AD ServicePrincipal Tenant ID: 930763d2-b2ba-4d30-bd7b-908bbf4ac227 
Resource Group Name: swarm1 
Resource Group Location: westeurope
4
5
6
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:
docker run -ti docker4x/create-sp-azure docker-for-azure-sp docker-for-azure
 Atenção! Para visualização completa do código utilize a rolagem horizontal
Em seguida, crie a implantação:
az group deployment create --name docker-swarm-deployment --resource-group d
Please provide string value for 'adServicePrincipalAppID' (? for help): xxxx
Please provide securestring value for 'adServicePrincipalAppSecret' (? for h
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:
{ 
 "$schema": "https://schema.management.azure.com/schemas/2015-01-01/
 "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" 
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
Para tanto, execute o seguinte comando:
docker run -ti docker4x/create-sp-azure docker-for-azure-sp docker-for-azure
 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.
 }, 
 "workerCount": { 
 "value": 2 
 }, 
 "workerVMSize": { 
 "value": "Standard_D1_v2" 
 } 
 } 
}
25
26
27
28
29
30
31
32
33
 
 Captura de tela do portal Microsoft Azure – Default DNS.
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á na porta 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 detrabalho.
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
 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:
swarm-manager000000:~$ docker ps 
CONTAINER ID IMAGE COM
1891668c2a41 docker4x/l4controller-azure:17.06.0-ce-azure2 "lo
5069b42130ea docker4x/meta-azure:17.06.0-ce-azure2 "me
1e55147b18b1 docker4x/guide-azure:17.06.0-ce-azure2 "/e
79db940f7e63 docker4x/logger-azure:17.06.0-ce-azure2 "py
456a2a2df8fd docker4x/init-azure:17.06.0-ce-azure2 "/e
20c56749ed4e docker4x/agent-azure:17.06.0-ce-azure2 "su
1
2
3
4
5
6
7
8
swarm-manager000000:~$ docker node ls 
ID HOSTNAME STATUS 
r62i4rpvp1kmxlf7goamkbsy8 swarm-worker000000 Ready 
rwk7lhwndmg86m4rkaa3upwmu * swarm-manager000000 Ready 
vtvh17ce0qsc37ecy8k5dng11 swarm-worker000001 Ready 
1
2
3
4
5
warm-manager000000:~$ docker node ls 
Error response from daemon: This node is not a swarm manager. Use "docker sw
 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);
SSH nas máquinas.
swarm-manager000000:~$ ssh docker@swarm-worker000001.oqzhphocr3cublz2fzkpyrw
 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
 Atenção! Para visualização completa do código utilize a rolagem horizontal
docker network create \ 
 --driver overlay \ 
 --subnet 10.0.9.0/24 \ 
 --gateway 10.0.9.99 \ 
 cnet
1
2
3
4
5
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 
1
2
3
4
 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 readi
 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.
 
docker service scale nginx3=10
5
6
 
 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:
mkdir -p /var/logs/docker 
sudo mount -t cifs //le66r7q7iia3klogs.file.core.windows.net/docker4azu
1
2
 Atenção! Para visualização completa do código utilize a rolagem horizontal
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. Compreendemoscomputação acelerada por GPU com Python com
CUDA/NVIDIA e finalizamos com a aprendizagem sobre Docker Swarm, com estudo de caso
em Microsoft Azure.
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);