04 - 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:
cat <<EOF| sudo tee /etc/modules-load.d/k8s.conf 
br_netfilter 
EOF 
 
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf 
1
2
3
4
5
 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
net.bridge.bridge-nf-call-ip6tables = 1 
net.bridge.bridge-nf-call-iptables = 1 
EOF 
sudo sysctl --system
6
7
8
9
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 
} 
1
2
3
4
 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.
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 
 } 
}
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
${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:
#!/bin/sh 
 
errorExit() { 
 echo "*** $*" 1>&2 
 exit 1 
} 
curl --silent --max-time 2 --insecure https://localhost:$
if ip addr | grep -q ${APISERVER_VIP}; then 
 curl --silent --max-time 2 --insecure https://${APISE
fi
1
2
3
4
5
6
7
8
9
10
 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:
# /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' sec
# use if not designated in their block 
#--------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11
12
13
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 no
#--------------------------------------------------------
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 
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
 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ço resolvível (nome DNS, endereço IP)
para o primeiro host doservidor 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.
balance roundrobin 
server ${HOST1_ID} ${HOST1_ADDRESS}:${APISERVER_SRC_PORT}
# [...]
48
49
50
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: 
path: /etc/keepalived/check_apiserver.sh 
name: check 
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
28
29
30
31
 Atenção! Para visualização completa do código utilize a rolagem
horizontal
O manifesto para haproxy, /etc/kubernetes/manifests/haproxy.yaml:
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
 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
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; d
 Active: active (running) since Fri 2020-05-29 12:25:4
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=/r
 
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 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
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 dockerd[4843 3]: time="2020-05
May 29 12:25:47 ubuntu2004 dockerd[48433]: time="2020-05-
May 29 12:25:47 ubuntu2004 systemd[1]: Started Docker App
17
18
19
20
21
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: 
1
2
3
4
5
6
7
8
9
 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:
User: developer 
Password: 
 
To login as administrator: 
oc login -u system:admin
10
11
12
13
14
Logged into "https://your-server-ip:8443" as "system:admi
You have access to the following projects and can switch 
 
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 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 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
 
Using project "myproject".
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
 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-
 deployment #1 deployed 2 minutes ago - 1 pod 
 
View details with 'oc describe /' or list everything with
1
2
3
4
5
6
7
8
9
10
11
12
13
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:
 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:
 Atenção! Para visualização completa do código utilize a rolagem
horizontal
Authentication required for https://your-server-ip:8443 (opens
Username: developer 
Password:
oc new-project dev --display-name="Project - Dev" --descriptio
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' co
oc new-app centos/ruby-25-centos7~https://github.com/sclorg/ru
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:
 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:
Now using project "my-project" on server "https://your-server-
Authentication required for https://your-server-ip:8443 (
Username: developer 
Password: 
Login successful. 
 
You have access to the following projects and can switch 
 
* dev 
my-project 
myproject 
 
Using project "dev".
1
2
3
4
5
6
7
8
9
10
11
12
oc status
Resultado:
 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:
 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:
In project My Project (my-project) on server https://your-serv
You have no services, deployment configs, or build configs. 
Run 'oc new-app' to create an application.
Tag deployment-example:latest set to openshift/deployment-exam
--> Found image da61bb2 (4 years old) in image stream "my
 * This image will be deployed in deployment config "d
 * Port 8080/tcp will be load balanced by service "dep
 * Other containers can access this service through th
1
2
3
4
 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:
 * WARNING: Image "my-project/deployment-example:lates--> Creating resources ... 
 deploymentconfig.apps.openshift.io "deployment-exampl
 service "deployment-example" created 
--> Success 
 Application is not exposed. You can expose services t
 'oc expose svc/deployment-example' 
 Run 'oc status' to view your app.
5
6
7
8
9
10
11
12
In project My Project (my-project) on server https://your
svc/deployment-example - 172.30.87.146:8080 
dc/deployment-example deploys istag/deployment-example:la
deployment #1 deployed 36 seconds ago - 1 pod 
2 infos identified, use 'oc status --suggest' to see deta
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:
NAME TYPE CLUSTER-IP EXTERNAL
deployment-example ClusterIP 172.30.87.146 8080/TCP
1
2
Name: deployment-example 
Namespace: my-project 
Labels: app=deployment-example 
Annotations: openshift.io/generated-by=OpenShiftNew
Selector: app=deployment-example,deploymentconfi
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
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
deployment-example-1-b9prf 1/1 Running 0 
1
2
3
NAME HOST/PORT PATH SE
deployment-example deployment-example-my-project.your-s
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.
javascript:void(0)
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.
 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 
 
@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) 
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
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”.
 
# Add arrays on GPU 
C = Add(A, B)
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
 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.
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 libxra
 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
# packages in environment at /home/sammy/anaconda3: 
# Name Version Build
_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
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
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 maisdetalhado 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, iter
 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.thr
 startY = cuda.blockDim.y * cuda.blockIdx.y + cuda.thr
 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) 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 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.
 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.to_host() 
 dt = timer() - start 
 
 print "Mandelbrot created on GPU in %f s" % dt 
 
 imshow(gimage)
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:
$sudo apt-get update 
 
$ sudo apt-get install \ 
 apt-transport-https \ 
 ca-certificates \ 
 curl \ 
1
2
3
4
5
6
 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
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | su
$ echo \ 
 "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-arch
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.lis
 gnupg \ 
 lsb-release
7
8
 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
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.
$ sudo apt-get install docker-ce=<VERSION_STRING> docker-ce-cl
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": { 
az login 
 
To sign in, use a web browser to open the page https://aka.ms/
 "name": "xxxxx", 
 "type": "user" 
 } 
 } 
]
 Atenção! Para visualização completado 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
{ 
 "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
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).
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:
 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
docker run -ti docker4x/create-sp-azure sp1 swarm1 westeurope
Your access credentials =================================
AD ServicePrincipal App ID: 98369e6d-9d9c-419d-86fa
AD ServicePrincipal App Secret: FITLMrNLMpokhi3YvZPbm7y
AD ServicePrincipal Tenant ID: 930763d2-b2ba-4d30-bd7b
Resource Group Name: swarm1 
Resource Group Location: westeurope
1
2
3
4
5
6
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.
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:
 Atenção! Para visualização completa do código utilize a rolagem
horizontal
Você precisará fornecer:
adServicePrincipalAppID;
adServicePrincipalAppSecret;
chave SSH pública.
docker run -ti docker4x/create-sp-azure docker-for-azure-sp do
az group deployment create --name docker-swarm-deployment --re
Please provide string value for 'adServicePrincipalAppID' (? f
Please provide securestring value for 'adServicePrincipalAppSe
Please provide string value for 'sshPublicKey' (? for help): s
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/schem
 "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
 Atenção! Para visualização completa do código utilize a rolagem
horizontal
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;
docker run -ti docker4x/create-sp-azure docker-for-azure-sp do
 } 
 } 
}
31
32
33
SSH targets.
 
 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 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
 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
warm-manager000000:~$ docker node ls 
Error response from daemon: This node is not a swarm manager. 
swarm-manager000000:~$ docker ps 
CONTAINER ID IMAGE1891668c2a41 docker4x/l4controller-azure:17.06.0-c
5069b42130ea docker4x/meta-azure:17.06.0-ce-azure2
1e55147b18b1 docker4x/guide-azure:17.06.0-ce-azure
79db940f7e63 docker4x/logger-azure:17.06.0-ce-azur
456a2a2df8fd docker4x/init-azure:17.06.0-ce-azure2
20c56749ed4e docker4x/agent-azure:17.06.0-ce-azure
1
2
3
4
5
6
7
8
swarm-manager000000:~$ docker node ls 
ID HOSTNAME STATU
r62i4rpvp1kmxlf7goamkbsy8 swarm-worker000000 Ready
rwk7lhwndmg86m4rkaa3upwmu * swarm-manager000000 Ready
vtvh17ce0qsc37ecy8k5dng11 swarm-worker000001 Ready
1
2
3
4
5
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.
 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);
docker logs $(docker ps -a | grep init-azure | cut -d' ' -f1)
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.
swarm-manager000000:~$ ssh docker@swarm-worker000001.oqzhphocr
 
 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:
 Atenção! Para visualização completa do código utilize a rolagem
horizontal
docker service create --network cnet --name nginx1 -p 80:80 ng
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:
 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:
 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.
swarm-worker000001:~$ docker logs -f d7e9d806f872 
Error response from daemon: configured logging driver does not 
docker service create --network cnet --name nginx2 -p 81:
docker service create --network cnet --name nginx3 -p 82:
docker service create --network cnet --name nginx4 -p 0:8
docker service create --network cnet --name nginx5 nginx 
 
docker service scale nginx3=10
1
2
3
4
5
6
 
 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.
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);