Prezi logo
Log in
Loading…

Docker

DR

Dielly Rodrigues Vial

Transcript

Projeto Cadastro

Alterando o mongodb

Configurando o Mongodb

Inicio

Configurando o nodejs

Configurando o docker-compose

Docker-Compose

para usar a partir do front-end

Criando a estrutura

Construindo a aplicação

$docker-compose up

// testando o front-end

(localhost:88)

// testando o back-end

(localhost:3001)

$ vim docker-compose.yml

version: '3'

services:

db:

image: mongo:3.4

backend:

image: node:8.1

volumes:

- ./backend:/backend

ports:

- 3001:3000

command: bash -c "cd /backend && npm i && node app"

frontend:

image: nginx:1.13

volumes:

- ./frontend:/usr/share/nginx/html/

ports:

- 88:80

/* alterando o index.html no front end */

<html>

<head>

<meta charset='utf-8'>

<title>Cadastro Simples</title>

<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">

</head>

<body>

<div class="container">

<h1>Cadastro Simples</h1>

<hr>

<div>

<input name='id' type='hidden' />

<div class="form-group">

<label for="Name"></label>

<input class='form-control' name='name' placeholder='Digite o nome' />

</div>

<button class='btn btn-success' save>Salvar</button>

</div>

<table class="table" id='clients'>

<thead>

<tr>

<th>Nome</th>

<th>Ações</th>

</tr>

</thead>

<tbody id="clientsRows"></tbody>

</table>

</div>

<script src='https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js'></script>

<script>

const API = 'http://localhost:3001'

const createButton = (label, type) => {

return $('<button>').addClass(`btn btn-${type}`).html(label)

}

const renderRows = clients => {

const rows = clients.map(client => {

const updateButton = createButton('Atualizar', 'warning')

updateButton.click(() => loadClient(client))

const removeButton = createButton('Excluir', 'danger')

removeButton.click(() => removeClient(client))

return $('<tr>')

.append($('<td>').append(client.name))

.append($('<td>').append(updateButton).append(removeButton))

})

$('#clientsRows').html(rows)

}

const loadClient = client => {

$('[name=id]').val(client._id)

$('[name=name]').val(client.name)

}

const removeClient = client => {

$.ajax({

method: 'DELETE',

url: `${API}/clients/${client._id}`,

success: getClients

})

}

const getClients = () => {

$.ajax({

url: `${API}/clients`,

success: clients => {

renderRows(clients)

$('[name]').val('')

}

})

}

const saveClient = () => {

const _id = $('[name=id]').val()

const name = $('[name=name]').val()

$.ajax({

method: _id ? 'PUT' : 'POST',

url: `${API}/clients/${_id}`,

data: _id ? { _id, name } : { name },

success: getClients

})

}

$(() => {

getClients()

$('[save]').click(saveClient)

})

</script>

</body>

</html>

$vim /root/curso-docker/node-mongo-compose/backend/app.js

const express = require('express')

const restful = require('node-restful')

const server = express()

const mongoose = restful.mongoose

//Database

mongoose.Promise = global.Promise

mongoose.connect('mongodb://db/mydb')

// Teste

server.get('/',(req, res, next) => res.send('Backend'))

// Start Server

server.listen(3000)

/*alterando o app.js no backend*/

const express = require('express')

const restful = require('node-restful')

const server = express()

const mongoose = restful.mongoose

const bodyParser = require('body-parser')

const cors = require('cors')

// Database

mongoose.Promise = global.Promise

mongoose.connect('mongodb://db/mydb')

// Teste

//server.get('/',(req, res, next) => res.send('Backend'))

// Midleware

server.use(bodyParser.urlencoded({extended:true}))

server.use(bodyParser.json())

server.use(cors())

// ODM

const Client = restful.model('Client',{

name: { type: String, required: true }

})

// Rest Api

Client.methods(['get', 'post', 'put', 'delete'])

Client.updateOptions({new: true, runValidators: true})

// Routes

Client.register(server, '/clients' )

// Start Server

server.listen(3001)

$ vim /root/curso-docker/node-mongo-compose/frontend/index.html

<h1> FrontEnd </h1>

$ /root/curso-docker/node-mongo-compose/backend# npm init -y

Wrote to /root/curso-docker/node-mongo-compose/backend/package.json:

$ vim /root /root/curso-docker/node-mongo-compose/backend

{

"name": "backend",

"version": "1.0.0",

"description": "",

"main": "app.js",

"scripts": {

"test": "echo \"Error: no test specified\" && exit 1"

},

"keywords": [],

"author": "",

"license": "ISC"

}

/ pasta backend/

$ npm i --save express@4.15.3 mongoose@4.11.1 node-restful@0.2.6 body-parser@1.17.2 cors@2.8.3

$ rm node_modules/

$ cat package.json

{

"name": "backend",

"version": "1.0.0",

"description": "",

"main": "app.js",

"scripts": {

"test": "echo \"Error: no test specified\" && exit 1"

},

"keywords": [],

"author": "",

"license": "ISC",

"dependencies": {

"body-parser": "^1.17.2",

"cors": "^2.8.3",

"express": "^4.15.3",

"mongoose": "^4.11.1",

"node-restful": "^0.2.6"

}

$mkdir /root/curso-docker/node-mongo-compose

$mkdir /root/curso-docker/node-mongo-compose/backend

$mkdir /root/curso-docker/node-mongo-compose/frontend

/ instalação Docker-compose /

apt-get install docker-compose

Redes

Visão Geral

Bridge network

Host Network

None network

parte3 ( adicionando container em uma nova rede )

parte2 ( criando nova rede )

parte4 ( teste de conexão )

parte1 (testes iniciais)

  • bridge - padrão (isolamento da rede)

  • sem rede -

  • host network - conectividade direta

  • rede overlay - (swarm)

docker network ls

NETWORK ID NAME DRIVER SCOPE

6911aec96685 bridge bridge local

a8f83a583d35 host host local

9a453fbaa86a none null local

/criando uma nova rede do tipo bridge / ***

docker network create --driver bridge rede_teste

/ ver os dados da nova rede que criei /

docker network inspect rede_teste

/ rodar o container especificando a rede / ***

docker container run -d --name debianteste --net rede_teste debian sleep 900

/buscar o ip do container pelo inspect/

docker container inspect debianteste |grep IP

/buscar o ip do container por comandos linux dentro do container/

docker container exec -it debianteste bash -c "ip addr"

/conectar em uma nova rede/ ***

docker network connect bridge debianteste

/buscar o ip do container pelo inspect/

docker container inspect debianteste |grep IP

/buscar o ip do container por comandos linux dentro do container/

docker container exec -it debianteste bash -c "ip addr"

/subindo sem rede/

docker container run -d --net none nginx

/visualizando rede do container/

docker container run --rm debian bash -c "ip addr "

/subindo sem rede , e mostrando com o comando /

docker container run -it --net none debian bash -c "ip addr "

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000

link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00

inet 127.0.0.1/8 scope host lo

valid_lft forever preferred_lft forever

/ver os dados da rede bridge/

docker network inspect bridge

/verificar ip/

docker container run -it debian ip addr

/ping/

docker container run -it debian bash -c "ping 172.17.0.3"

docker container run -it debian ping 172.17.0.3

docker container run -it debian ping www.uol.com.br

/verificar as redes

docker network ls

/ rodar o container especificando a rede / ***

docker container run -d --name debianteste2 --net rede_teste debian sleep 900

/buscar o ip do container pelo inspect/

docker container inspect debianteste2 |grep IP

/buscar o ip do container por comandos linux dentro do container/

docker container exec -it debianteste2 bash -c "ip addr"

/conectar em uma nova rede/ ***

docker network connect bridge debianteste2

/buscar o ip do container pelo inspect/

docker container inspect debianteste2 |grep IP

/buscar o ip do container por comandos linux dentro do container/

docker container exec -it debianteste2 bash -c "ip addr"

/subindo um container no modo daemon /

docker container run -d --name debianteste3 --net host debian sleep 900

/verificando as informações do container/

docker network inspect debianteste3

/verificando o ip atraves do bash/

docker container exec -it debianteste3 ip addr

docker container exec -it debianteste3 bash -c "ip addr"

/ ping /

docker container exec -it debianteste ping <ipdebianteste2>

docker container exec -it debianteste bash -c "ping <ipdebianteste2>"

docker container exec -it debianteste2 ping <ipdebianteste>

docker container exec -it debianteste2 bash -c "ping <ipdebianteste>"

Mão na Massa II

Build

Parte 1

Docker hub

Construindo um novo container (copy)

Construindo um novo container (ARG)

Build

Construindo um novo container (Dev python)

Build

Parte 2

upload das imagens

Parte 3

Construindo um novo container (Dev python)

/tageando/

$docker image tag nginx-dev diellyr/nginx-dev:1.0

/logando no docker hub/

$docker login --username=diellyr

/subindo a imagem para o docker hub/

docker image ls

docker image push diellyr/nginx-dev:1.0

docker container run -it -v $(pwd):/app -p 8000:8000 --name python-server nginx-dev

/ lendo um volume de um container a partir de outro container /

docker container run -it --volumes-from=python-server debian ls /root

$vim index.html

<p>hello from python</p>

$vim run.py

import logging

import http.server

import socketserver

import getpass

class MyHTTPHandler(http.server.SimpleHTTPRequestHandler):

def log_message(self, format, *args):

logging.info("%s - - [%s] %s\n"% (

self.client_address[0],

self.log_date_time_string(),

format%args

))

logging.basicConfig(

filename='/log/http-server.log',

format='%(asctime)s - %(levelname)s - %(message)s',

level=logging.INFO

)

logging.getLogger().addHandler(logging.StreamHandler())

logging.info('Inicializando...')

PORT = 8000

httpd = socketserver.TCPServer(("", PORT), MyHTTPHandler)

logging.info('escutando a porta: %s', PORT)

logging.info('usuário: %s', getpass.getuser())

httpd.serve_forever()

$vim Dockerfile

FROM python:3.6

LABEL maintainer 'Dielly'

RUN useradd www && \

mkdir /app && \

mkdir /log && \

chown www /log

USER www

VOLUME /log

WORKDIR /app

EXPOSE 8000

ENTRYPOINT ["/usr/local/bin/python"]

CMD ["run.py"]

docker image build -t nginx-dev .

docker image ls

$vim Dockerfile

FROM nginx:latest

LABEL maintainer '<Dielly>'

ARG NGINX_PATH=/usr/share/nginx/html

ENV NGINX_PATH=${NGINX_PATH}

docker image build -t nginx-arg .

docker container run nginx-arg bash -c 'echo $NGINX_PATH '

/usr/share/nginx/html

docker container run nginx-arg bash -c 'ls $NGINX_PATH '

50x.html

index.html

docker container run nginx-arg bash -c 'echo $NGINX_PATH/index.html '

/usr/share/nginx/html/index.html

docker inspect nginx-arg |grep maintainer

"maintaner": "<Dielly>"

$ vim Dockerfile

FROM nginx

LABEL maintaner '<Dielly>'

RUN echo '<h1>Sem Conteudo</h1>' > /usr/share/nginx/html/conteudo.html

COPY *.html /usr/share/nginx/html/

docker image build -t nginx-copy .

docker container run nginx-copy bash -c 'ls /usr/share/nginx/html/ '

? verificar porque o nginx esta abrindo outro index.html (debugar)

MÃO NA MASSA - I

CONCEITOS

Docker Hub

Docker Commands

Run

hello-world

Instalação do Docker

Run

( pull, create, start, exec)

docker run -it ubuntu ls

Antes

  • pull
  • create
  • start
  • exec

Docker Commands

https://hub.docker.com/

docker run -it ubuntu ls

Antes

docker container run -it ubuntu ls

Agora

docker container run debian

Commands:

attach Attach local standard input, output, and error streams to a running container

build Build an image from a Dockerfile

commit Create a new image from a container's changes

cp Copy files/folders between a container and the local filesystem

create Create a new container

diff Inspect changes to files or directories on a container's filesystem

events Get real time events from the server

exec Run a command in a running container

export Export a container's filesystem as a tar archive

history Show the history of an image

images List images

import Import the contents from a tarball to create a filesystem image

info Display system-wide information

inspect Return low-level information on Docker objects

kill Kill one or more running containers

load Load an image from a tar archive or STDIN

login Log in to a Docker registry

logout Log out from a Docker registry

logs Fetch the logs of a container

pause Pause all processes within one or more containers

port List port mappings or a specific mapping for the container

ps List containers

pull Pull an image or a repository from a registry

push Push an image or a repository to a registry

rename Rename a container

restart Restart one or more containers

rm Remove one or more containers

rmi Remove one or more images

run Run a command in a new container

save Save one or more images to a tar archive (streamed to STDOUT by default)

search Search the Docker Hub for images

start Start one or more stopped containers

stats Display a live stream of container(s) resource usage statistics

stop Stop one or more running containers

tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE

top Display the running processes of a container

unpause Unpause all processes within one or more containers

update Update configuration of one or more containers

version Show the Docker version information

wait Block until one or more containers stop, then print their exit codes

https://www.digitalocean.com/community/tutorials/como-instalar-e-usar-o-docker-no-ubuntu-18-04-pt

  • 1 - Criar uma conta no docker-hub

  • 2 - Login no docker hub (Console)

docker container run -it ubuntu ls

Agora

docker login --username <usuario>

  • Daemon ( background )

https://docs.docker.com/engine/reference/commandline/login/

/ abra os 2 comandos abaixo em terminais diferentes /

$ watch docker container ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

$ docker container run debian sleep 6

$ docker container ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

d6a290c184b2 debian "bash" 9 seconds ago Exited (0) 7 seconds ago competent_hellman

316042037dff debian "bash --version" 18 seconds ago Exited (0) 17 seconds ago amazing_hypatia

..

docker container run debian sleep 6

docker container run -d debian sleep 10

Example output:

$ docker container run hello-world

Hello from Docker!

This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:

1. The Docker client contacted the Docker daemon.

2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

(amd64)

3. The Docker daemon created a new container from that image which runs the

executable that produces the output you are currently reading.

4. The Docker daemon streamed that output to the Docker client, which sent it

to your terminal.

To try something more ambitious, you can run an Ubuntu container with:

$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:

https://hub.docker.com/

For more examples and ideas, visit:

https://docs.docker.com/get-started/

$ docker images hello-world

REPOSITORY TAG IMAGE ID SIZE

hello-world latest fce289e99eb9 1.84kB

Commands:

attach Attach local standard input, output, and error streams to a running container

build Build an image from a Dockerfile

commit Create a new image from a container's changes

cp Copy files/folders between a container and the local filesystem

create Create a new container

diff Inspect changes to files or directories on a container's filesystem

events Get real time events from the server

exec Run a command in a running container

export Export a container's filesystem as a tar archive

history Show the history of an image

images List images

import Import the contents from a tarball to create a filesystem image

info Display system-wide information

inspect Return low-level information on Docker objects

kill Kill one or more running containers

load Load an image from a tar archive or STDIN

login Log in to a Docker registry

logout Log out from a Docker registry

logs Fetch the logs of a container

pause Pause all processes within one or more containers

port List port mappings or a specific mapping for the container

ps List containers

pull Pull an image or a repository from a registry

push Push an image or a repository to a registry

rename Rename a container

restart Restart one or more containers

rm Remove one or more containers

rmi Remove one or more images

run Run a command in a new container

save Save one or more images to a tar archive (streamed to STDOUT by default)

search Search the Docker Hub for images

start Start one or more stopped containers

stats Display a live stream of container(s) resource usage statistics

stop Stop one or more running containers

tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE

top Display the running processes of a container

unpause Unpause all processes within one or more containers

update Update configuration of one or more containers

version Show the Docker version information

wait Block until one or more containers stop, then print their exit codes

docker --help

Management Commands:

builder Manage builds

config Manage Docker configs

container Manage containers

engine Manage the docker engine

image Manage images

network Manage networks

node Manage Swarm nodes

plugin Manage plugins

secret Manage Docker secrets

service Manage services

stack Manage Docker stacks

swarm Manage Swarm

system Manage Docker

trust Manage trust on Docker images

volume Manage volumes

Passo 1 — Instalando o Docker

O pacote de instalação do Docker disponível no repositório oficial do Ubuntu pode não ser a versão mais recente. Para garantir que teremos a última versão, vamos instalar o Docker a partir do repositório oficial do projeto. Para fazer isto, vamos adicionar uma nova fonte de pacotes, adicionar a chave GPG do Docker para garantir que os downloads são válidos, e então instalar os pacotes.

Primeiro, atualize sua lista atual de pacotes:

$ sudo apt update

Em seguida, instale alguns pacotes de pré-requisitos que permitem que o apt utilize pacotes via HTTPS:

sudo apt install apt-transport-https ca-certificates curl software-properties-common

Então adicione a chave GPG para o repositório oficial do Docker em seu sistema:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Adicione o repositório do Docker às fontes do APT:

sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"

A seguir, atualize o banco de dados de pacotes com os pacotes Docker do repositório recém adicionado:

sudo apt update

Certifique-se de que você irá instalar a partir do repositório do Docker em vez do repositório padrão do Ubuntu:

apt-cache policy docker-ce

Você verá uma saída como esta, embora o número da versão do Docker possa estar diferente:

Output of apt-cache policy docker-ce

docker-ce:

Installed: (none)

Candidate: 18.03.1~ce~3-0~ubuntu

Version table:

18.03.1~ce~3-0~ubuntu 500

500 https://download.docker.com/linux/ubuntu bionic/stable amd64 Packages

Observe que o docker-ce não está instalado, mas o candidato para instalação é do repositório do Docker para o Ubuntu 18.04 (bionic).

........

Finalmente, instale o Docker:

sudo apt install docker-ce

O Docker agora deve ser instalado, o daemon iniciado e o processo ativado para iniciar na inicialização. Verifique se ele está sendo executado:

sudo systemctl status docker

docker container ps

CONTAINER ID IMAGE COMMAND CREATED STATUS

dff8ae30bf84 debian "sleep 10" 3 seconds ago Up 2 seconds

docker container ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS

72c58885dad1 debian "sleep 10" About a minute ago Exited (0) About a minute ago

dff8ae30bf84 debian "sleep 10" 2 minutes ago Exited (0) 2 minutes ago

8d7853abd995 debian "sleep 10" 5 minutes ago Exited (0) 5 minutes ago

Docker Engine

Exportando Portas

O que é o Docker?

Exportando Volumes

Nomeando os containers

Reutilizando os containers

Images

Interativo

Porquê Container?

docker container run -p 8081:80 -d nginx

Exemplo de path: /opt/dados/html

docker container run --name debian-teste -d debian sleep 10

docker container start -ai teste

vim index.html

8081 - porta externa no Sistema operacional

80 - porta interna , aplicação no container

Não é Virtualização tradicional

/ Repositório Local /

docker image ls ( docker images )

REPOSITORY TAG IMAGE ID CREATED SIZE

mongo 3.4 0a8d98121dec 4 days ago 426MB

nginx-dev latest 9bc2fc42ea25 5 days ago 924MB

diellyr/nginx-copy 1.0 6775d2898cee 5 days ago 109MB

...

/ Registry /

docker search debian

NAME DESCRIPTION STARS OFFICIAL AUTOMATED

ubuntu Ubuntu is ... 9640 [OK]

debian Debian is ... 3112 [OK]

arm32v7/debian Debian is ... 58 [OK]

itscaro/debian-ssh debian:jessie 25 [OK]

ex: o container "teste" será utilizado novamente com o mesmo comando ou ação realizado

docker container ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

657d56c29764 debian "sleep 10" 5 seconds ago Up 3 seconds debian-teste

docker container run debian bash --version

GNU bash, version 4.4.12(1)-release (x86_64-pc-linux-gnu)

Copyright (C) 2016 Free Software Foundation, Inc.

License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>

This is free software; you are free to change and redistribute it.

There is NO WARRANTY, to the extent permitted by law.

docker container run --rm debian bash --version (não registra no histórico)

docker container run --rm debian bash ls

bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var

/ rodando comando dentro do container /

docker container run -it debian bash

( ls , touch ... )

root@fb6f7620cf4d:/# ls

bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var

<html>

<head>

<title>Curso de Docker</title>

</head>

<body>

<h1>Teste nginx</h1>

</body>

</html>

O Container fornece uma camada adicional de abstração e automação de virtualização de nível de sistema operacional no Windows e Linux

/ parando o container /

docker container stop teste

/ removendo o container /

docker container rm teste

docker container run -d -p 8081:80 -v $(pwd):/usr/share/nginx/html nginx

Docker é uma tecnologia de software que fornece containers, promovido pela empresa Docker, Inc.

Escrito em Go

O Docker fornece uma camada adicional de abstração e automação de virtualização de nível de sistema operacional no Windows e no Linux

localhost:8081

docker container ps

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

be6d529377a4 nginx "nginx -g '…" 47 seconds ago Up 46 seconds 0.0.0.0:8081->80/tcp vigorous_mcnulty

  • Padronização
  • portabilidade
  • reaproveitamento
  • redução de mão de obra
  • adaptabilidade
  • isolantes

Gerenciando o Container

Gerenciando Imagens

https://hub.docker.com/

docker search <>

docker image ls

--- ou --- docker images

docker image pull <>

docker ps

docker image inspect <>

docker image tag <> novonome (terá o mesmo hash)

docker image rm <idimagem> ( remove images )

docker rmi <Imageid> (remove imagens)

docker container stop <>

docker container start <>

docker container restart <>

docker container logs <>

docker container inspect <>

docker container exec <Names> ls

docker container run <Nomde da Imagem> ls

docker container ls ou ps

docker container rm <idcontainer> (remove containers)

Docker -> Kernel

Vantagens Docker

Genealogia do Docker

Registry

Economia de recursos: os containers são definidos como uma imagem em execução ao invés de serem um ambiente read-only. Nessa imagem é gerado um layer extra que armazena todos os dados de uma determinada operação. A natureza de compartilhamento do disco do container docker permite que seja criada uma pilha de imagens somente leitura, com um amontoado para cada container, economizando nos recursos utilizados.

Maior disponibilidade do sistema: de uma maneira simples, o container docker deixa a máquina mais “leve”, com espaço para executar outros programas. Isso acontece porque o docker compartilha o Sistema Operacional, o que torna os processos mais ágeis.

Compartilhamento: os arquivos podem ser compartilhados entre o container e o host, inclusive utilizando a nuvem para o processo. Isso torna mais fácil a implementação de modificações, permitindo que seja adotada uma gestão mais centralizada. Com isso, o espaço para testes fica mais leve, o que permite, por exemplo, baixar uma solução durante uma reunião.

Facilidade de gerenciamento: o grupo de máquinas físicas ou virtuais onde os containers são executados é chamado de cluster e precisa ser monitorado constantemente. Para isso, foram criadas ferramentas específicas, como o Openshift, que atuam em conjunto com o docker e controlam o equipamento que permite a execução dos containers.

Ambientes similares: a possibilidade de transformar uma aplicação em imagem docker permite que ela seja alocada como container em ambientes diferentes, fazendo com que ela possa ser utilizada tanto no computador do desenvolvedor quanto no servidor da produção, por exemplo.

Aplicação como pacote completo: graças à imagem do docker, o empacotamento da aplicação e das suas dependências é possível, simplificando o processo de distribuição. Assim, o ambiente pode ser alterado de maneira fácil e rápida. Por causa da estrutura de layers, somente a alteração é transferida na realização de updates.

Padronização e replicação: criar e mudar a infraestrutura é muito mais simples com o container docker, pois as imagens do docker são construídas através de arquivos de definição. Assim, o escalonamento da estrutura fica muito mais simples. Isso permite que um novo colaborador da equipe de TI posso integrar e receber o ambiente de trabalho com apenas alguns comandos, por exemplo.

Acesso à comunidade: outra vantagem do container docker é que ele torna possível conseguir modelos de infraestrutura prontos para integrações com alto grau de complexidade através do acesso ao repositórios de imagens docker. É possível usar as imagens do repositório e configurar os parâmetros para que ele se adeque ao ambiente.

Chroot

- Isolamento de Serviços

- Isolamento de Serviços, mais avançado, com comandos próprios ...

Vantagens Docker

Facilidade de

Gerenciamento

Ambientes

Similares

Economia

de recursos:

Facilidade de

Compartilhamento:

Maior disponibilidade

do sistema:

Padronização

e Replicação

Aplicação

com Layers

Acesso

a Comunidade:

- Isolamento de Serviços, portabilidade, padronização, reaproveitamento, adaptabilidade, volumes , network,