Transcrições
1. INTRODUÇÃO DO CURSO: Olá e bem-vindo ao curso de gerenciamento de
contêineres com Pac-Man. Meu nome é Andre
balance e estou aqui para ajudá-lo a aprender
os benefícios da conteinerização e também
como criar e gerenciar contêineres usando a ferramenta de gerenciamento de
contêineres Pokémon, gostaria de
especificar o board man é extremamente parecido com o Docker. O ganho de conhecimento aqui também pode ser usado ao trabalhar
com o Docker. Agora vamos começar o curso falando um pouco sobre mim. Sou engenheiro certificado pela Red Hat e também especialista
em trabalhar com contêineres
e Kubernetes Minha segunda área de
especialização é a InfoSec. Também sou certificado pela CompTIA Security Plus 35 milhas para CISOs. Então, agora que você sabe
um pouco sobre mim, veja o que
abordaremos neste curso. Vamos fazer uma breve visão geral do que devemos abordar
durante este curso. Aprenderemos sobre
contêineres, sua arquitetura, em seus benefícios depois, que abordaremos áreas
mais práticas. E discutiremos os registros de
contêineres. Eles são e como
configurá-los no pod man. Em seguida, vamos nos aprofundar no
gerenciamento de contêineres, onde veremos como
criar serviços em contêineres. Agora podemos gerenciar bem
os contêineres, se também pudermos gerenciar imagens. Então é isso que
faremos no próximo módulo. Os contêineres têm, por padrão, armazenamento
efêmero. Portanto, se quisermos que nossas alterações persistam além da
morte de um contêiner, precisamos entender
como alocar o armazenamento de
persistência
para os contêineres. E abordaremos isso
no quinto módulo. No sexto módulo sete, vamos nos concentrar em Rede de
Contêineres, onde aprenderemos sobre
vinculação de portas e criação de rede. Como hoje, concluiremos este curso aprendendo como criar nossas próprias
imagens de contêiner por meio do uso de arquivos Docker e diretórios
de trabalho. Agora que temos uma
boa visão geral do que abordaremos,
vamos começar.
2. Contêineres explicados: Agora, com nosso primeiro módulo, falaremos um pouco
sobre contêineres, o que são e os
benefícios da conteinerização. Concluiremos este
módulo configurando um ambiente de laboratório onde podemos executar todos os nossos exercícios práticos
para os próximos módulos. Então, sem mais delongas,
vamos começar. Agora vamos ver um pouco
como os contêineres funcionam. Agora, os aplicativos de software
dependem das bibliotecas do sistema, arquivos de
configuração ou dos serviços oferecidos pelo
ambiente de tempo de execução. Além disso, o ambiente de tempo
de
execução de um aplicativo de software
é instalado em um sistema operacional que é
executado em um host físico
ou em uma máquina virtual, os administradores instalam o
aplicativo dependências na parte superior desse sistema operacional. A principal desvantagem aplicativos de
software implantados
tradicionais é que essas dependências estão emaranhadas com o ambiente de
tempo de execução. Um aplicativo pode exigir versões
mais antigas ou mais recentes de um software de suporte e do software
fornecido pelo sistema operacional. É aí que entram os
contêineres. O contêiner é
um conjunto de um ou mais processos isolados do
resto do sistema. Pense nisso como um contêiner de
transporte físico. O contêiner de transporte é uma
forma padrão de empacotar e enviar. Ele é rotulado como carregado, descarregado e transportado
de um local para outro dentro de uma única caixa. conteúdo dos recipientes
é isolado
do conteúdo de
outros recipientes, para que eles não
afetem um ao outro. Então, eles estão isolados e
funcionam de forma independente. Então, quais são as características
de um contêiner? Bem, eles são executados diretamente
no sistema operacional host e compartilham esses recursos com todos os contêineres nesse sistema. Eles compartilharam o kernel do host. O kernel isola
os
processos do aplicativo do
resto do sistema. Eles exigem muito menos
recursos do que as máquinas virtuais, por isso são mais rápidos de
iniciar e implantar. E eles incluem todas as
dependências, como dependências de sistema e programação
e definições de configuração. Não importa onde você os
implantará, eles se comportarão da mesma forma. Agora que entendemos um pouco sobre arquitetura de contêineres, vejamos alguns termos úteis. O contêiner é um
processo ou um conjunto de processos que executam uma
imagem com restrições. A imagem é um pacote que contém todos os requisitos para executar esses processos ou aquele processo. Um registro é um local onde as imagens podem ser armazenadas
e recuperadas. velho é a ferramenta
de gerenciamento de contêineres, que usamos para gerenciar
imagens, contêineres e a
maneira como eles interagem. Outra
alternativa popular é o Docker. E o pod é um ou
vários contêineres, o que representa um
único aplicativo. Então, vamos dar uma olhada nos
benefícios da conteinerização. Primeiro, temos portabilidade. Um contêiner de aplicativo cria um pacote de software executável abstraído
do sistema operacional host. Portanto, ele não é dependente ou
vinculado ao sistema operacional de forma alguma, tornando-o portátil e permitindo que
ele seja executado de forma consistente e uniforme em
qualquer plataforma ou nuvem, então temos velocidade porque não
há sistema operacional para inicializar. Isso também significa que
a hora de início é muito baixa. Os nervos também são muito eficientes se o
software executado em um
ambiente em contêiner compartilha o kernel do sistema operacional da máquina host. Os desenvolvedores podem compartilhar as
camadas do aplicativo entre contêineres. Além disso, os contêineres têm uma capacidade inerentemente menor do que as máquinas virtuais exigem tempos
mínimos de inicialização, permitindo que os desenvolvedores
executem mais contêineres
na mesma capacidade
de computação de um virtual máquina. Consequentemente, isso aumenta
a eficiência do servidor e reduz os custos associados de
servidor e licenciamento. E, por último, como
afirmado anteriormente, não há sistema operacional para ambos os contêineres, também
há menos sobrecarga. Entendemos a arquitetura de
contêineres e os benefícios da
conteinerização. Configure o ambiente do laboratório. Primeiro, examinaremos os pré-requisitos
para configurar o laboratório. Depois, veremos
os comandos que devemos executar. Por fim, faremos uma
breve demonstração para ter nosso ambiente
de laboratório em funcionamento. Agora, em termos de pré-requisitos, precisamos de um host executando o Red Hat Enterprise Linux
versão oito ou superior. O host precisa estar conectado
à internet. Portanto, ele precisa de uma conexão ativa com a
Internet, que usaremos para
baixar o Birdman e
também as imagens de contêiner
anexadas ao nosso host. Precisamos de uma descrição de autoatendimento ou de
desenvolvedores. Isso significa que precisamos criar uma conta de desenvolvedor
com a Red Hat. Além disso, é recomendável que também
tenhamos uma conta em um repositório de contêineres de onde obteremos nossas imagens, como Docker ou argila. Mas isso não é obrigatório. Então, agora vamos dar uma olhada nos
comandos que
precisaremos para configurar nosso ambiente de
laboratório. Então, na verdade, não é
tão complicado. Há apenas três comandos
que precisamos executar. Primeiro dia de registro
do Subscription Manager, que registrará
nosso sistema usando nossa conta
e senha Red Hat. Depois disso, temos o
Subscription Manager anexado menos menos automático, que anexará a
assinatura ao nosso host. E, por fim, executaremos o
comando yum install container tools para instalar
a ferramenta de
gerenciamento de contêineres poor man a partir de repositórios
red heads depois de
registrarmos com sucesso nosso host. Então, agora vamos colocar todos esses
comandos em uso e configurar nosso
ambiente de laboratório em nossa breve demonstração. Primeiro, usaremos o comando
registrado
do Subscription Manager para registrar
meu sistema com a Red Hat. Vou inserir meu ID Red
Hat e também minha senha. Então eu só tenho que esperar um pouco. Como você pode ver,
a mensagem de saída é que o sistema foi registrado e o nome do sistema é localhost dot local domain. Usarei o comando anexar do
Gerenciador de
Assinaturas menos menos automático para anexar
minha assinatura ao meu host. Isso pode levar um pouco de tempo, mas depois que isso for feito, então eu tenho acesso aos repositórios de
cabeças de leitura também pode
ver uma mensagem pop-up aparecendo dizendo que
o registro é bem-sucedido e meu status
está inscrito adormecido. Usarei o
comando yum install container tools para instalar
a ferramenta de gerenciamento de contêineres chamada Pac-Man a partir de repositórios red
heads. Você pode ver
que o
download foi feito com êxito e está concluído. Agora. Parabéns.
Agora tenha um ambiente de
laboratório funcionando e funcionando.
3. Registros de contêineres: Anteriormente, configuramos
nosso ambiente de laboratório. Então, agora podemos falar sobre registros de
contêineres. Primeiro, faremos uma visão geral
teórica do que são os
registros de contêineres. E então passaremos
para a demonstração, onde faremos nosso próprio registro de contêiner
personalizado. Então, sem mais delongas,
vamos começar. Então, quais são nossos
registros de contêineres? Bem, para simplificar, há um
repositório de imagens. Um registro de contêiner
é um banco para armazenar e obter imagens de
contêiner. Um desenvolvedor carrega imagens
de
contêiner um registro de contêiner. Em seguida, você pode baixar essas
imagens de
um registro para um sistema local para executar e criar serviços em
contêiner
com base nessas imagens. Existem dois tipos de
registros, privados ou públicos. Você pode usar um registro público
ou privado no qual sua organização
controla a origem das imagens do contêiner, especialmente do lado
da segurança. Para baixar imagens
da maioria dos registros, primeiro
você precisa
ter uma conta com esses registros
e você pode fazer login nesse registro usando
a ferramenta de
gerenciamento de contêiner old man, mais especificamente, o comando
pot man login. Agora, o arquivo de
configuração padrão para
registros de contêiner é ensinado no arquivo de barra ETC slash container
slash registry.com. Agora, ambos os homens têm
a habilidade de executar contêineres implacáveis. Isso significa que podemos criar um arquivo
registry.com na página inicial do diretório user dot config
slash containers. Isso terá precedência sobre o geral
presente em barra, ETC slash container
slash registries.com. Agora, dentro do arquivo de
registro do contêiner, temos a seção de
pesquisa de registros. Na seção de
pesquisa do registro, há uma lista de
registro pesquisável configurada. Também temos os registros
na seção segura. Esses registros não são
protegidos com criptografia TLS. Então, agora que temos uma boa
visão geral teórica dos registros, vamos dar uma olhada em alguns comandos Pokémon práticos
e úteis para trabalhar com registros. Primeiro, temos o comando
old man login
usando o comando boat man
login, como podemos ver no exemplo, vou entrar no meu registered.com usando um
nome de usuário e senha. Em seguida, temos o comando pod
man info nos
dará informações sobre a configuração do homem PODD, incluindo registros pesquisáveis. E por último, temos o comando de busca do homem do
porto,
o comando de busca do homem do ponto. Posso acessar meus
registros e pesquisar por uma
palavra-chave específica, como HTTPD. Como exemplo, a pesquisa do PacMan, HTTPD pesquisará nos registros qualquer imagem de contêiner
que contenha a palavra-chave HTTPD. Então, sem mais delongas, vamos agora para
a demonstração e colocar nosso conhecimento aprendido
em prática. Primeiro, usarei o VIM
para mostrar o arquivo slash, ETC slash container slash
registered.com. Aqui temos os registros de
pesquisa não qualificados. Esses são os registros
através dos quais o pod man pesquisa. Quando procuro uma imagem, temos aqui o
registry.centos.org, quiet.docker.io, etc. Agora vou sair
deste documento em particular. Vou criar um novo caminho
usando o MK D ou Command. E meu novo caminho será contêineres de barra de
configuração de pontos. Agora vou copiar o arquivo slash
ETC slash containers slash registered.com para o caminho dos
contêineres de barra de configuração de ponto. Vou manter o mesmo
nome, registry.com. Agora, editarei esse
arquivo específico porque só quero que minha ferramenta
de
gerenciamento de contêiner pod man pesquise em
registry.access.redhead.com. Portanto, excluirei
todos os registros que não gostaria de usar, como pontos do Registro, CentOS.org, quiet.io
e docker.io. Em seguida, salvarei e
sairei deste documento. Agora vou fazer um comando de
pesquisa PubMed com o termo HTTPD para testar se meus
registros estão bem. E podemos ver claramente
que temos resultados aqui. Agora, vou limpar a tela e usar o comando port man info para obter informações sobre nossa configuração do
Pac-Man. E podemos ver claramente aqui que os registros pesquisáveis são
apenas registry.access.com. Então, o único que eu deixei dentro do arquivo dot config slash registries.com. Portanto, nossa demonstração funcionou perfeitamente. Muito obrigado e até
o próximo módulo.
4. Como gerenciar contêineres: Anteriormente, aprendemos
sobre registros de contêineres. Agora, neste módulo,
aprenderemos como gerenciar contêineres usando a ferramenta de gerenciamento de
contêineres pod man. Este será um módulo altamente
prático e encerraremos este
módulo com a demonstração, colocando em prática todo o nosso
conhecimento aprendido. Então, sem mais delongas,
vamos começar. Agora, em termos de comandos úteis, primeiro
temos o comando port
man pool,
especificando um registro e, especificando um registro e em seguida, a imagem dentro
desse repositório. Isso fará o download dessa
imagem para o host local. Depois, temos
o
comando Pokemon inspect especificando uma imagem salva
localmente. Isso nos dará informações
detalhadas sobre essa imagem do contêiner. Usando o comando pod man
images, podemos obter uma lista de imagens
salvas localmente e usando o comando poor man RMI
especificando um nome de imagem, podemos remover uma imagem salva
localmente. Agora, antes de entrarmos em contêineres em
execução, vamos fazer uma breve visão geral
dos estados nos quais um
contêiner pode ser encontrado. Ótimo, isso significa
que nosso contêiner foi criado, mas não começou a ser executado significa que
um contêiner está sendo executado com todos os
seus processos. Parar significa que um contêiner está parado e está
aguardando o início do sinal. Seus processos estão
esperando pela mesma coisa. Publicar significa que um contêiner e
seus processos são pausados enquanto isso significa que todos os
seus processos foram encerrados. Agora, vejamos
alguns comandos úteis para executar contêineres usando a ferramenta de
gerenciamento de contêineres poor man com o podium e o comando run. Podemos executar um comando
dentro de um contêiner. Podemos especificar o nome com
a opção minus-minus name. E no final do comando, especificamos a imagem na
qual esse contêiner é baseado usando a opção
menos d, que significa desanexado, significa que o contêiner será executado em modo destacado. Isso significa que o
contêiner será executado em segundo plano até ser interrompido. Usando o comando pot man ps, podemos listar todos os
contêineres em execução usando o comando pod man ps
com esta opção menos a, podemos listar todos os contêineres
em execução ou não. Usando o comando pod man logs. Podemos obter cargas
de um contêiner de nomes, o que pode
nos ajudar a solucionar possíveis problemas
associados a esse contêiner. Eu gostaria de especificar que, se usarmos a opção menos e, declararemos variáveis
ambientais que são passadas
para esse contêiner. Nós deportamos o comando man stop
especificando um nome de contêiner. Podemos parar um contêiner em execução com o comando de inicialização do Pac-Man. Novamente, especificando
o nome do contêiner. Podemos iniciar um contêiner parado usando o comando pod man RM. Podemos remover um contêiner
especificando seu nome. Com o comando Pac-Man cp. Podemos copiar arquivos do
host para um contêiner usando o comando old man exec especificando um nome de contêiner, podemos executar um comando dentro um contêiner de nome e
usando o comando pot man exec com
as opções menos IT especificando slash bin slash bash, podemos obter um terminal
dentro de um contêiner de nome. A opção menos i encaminhará todas as entradas do
host para o contêiner. E a
opção menos d nos
dará um pseudo terminal
dentro desse contêiner. Agora que temos
uma boa visão geral de todos os comandos importantes necessários para executar contêineres usando a ferramenta de
gerenciamento de contêiner de pod. Vamos para a demonstração. Agora, primeiro, procurarei uma imagem HTTP D usando o comando search do
pod man. Vou apenas rolar um pouco para cima
e dentro da descrição, posso ver um servidor Apache
HTTP 2.4. Copiarei o nome
dessa imagem e
limparei a tela e usarei o
comando Postman pull para baixá-la localmente. Como você pode ver, ele está tentando extrair a imagem
do registro, está obtendo as assinaturas de origem e copiando as
bolhas enquanto falamos. Então, vamos esperar um pouco. Portanto, a votação
foi bem-sucedida. Agora, para validar isso,
usarei o
comando pod man images e podemos ver que
nossa imagem está presente aqui. Em seguida, usarei o comando port
mapping spec para obter informações
detalhadas sobre
essa imagem específica. Podemos ver muitas
informações aqui. Primeiro, podemos ver o usuário
sob o qual essa imagem é executada, que é usada em 1001. Também podemos ver detalhes sobre as portas expostas da
imagem, que são 8088443. Um resumo e uma descrição do que esta imagem deve fazer, o diretório
de trabalho desta imagem, e também detalhes
sobre o fornecedor da imagem que é
ruiva incorporada, e a versão da
imagem que é 2.4. Vou apenas limpar a tela. Agora. Agora vou usar
o comando port VLAN run especificando o nome
do meu contêiner por meio da opção minus-minus
name. E será chamado de
aplicativo da web e a imagem na
qual baseá-lo. E podemos ver claramente que
o contêiner começou. Ele nos dá alguns
logs e erros, mas funcionou corretamente. Só vou sair da tela. Agora vou usar o comando boatman ps minus a para
listar todos os contêineres. E podemos ver claramente
nosso contêiner de aplicativos da web, que foi criado há
39 segundos. Vou removê-lo usando o comando rm poor man
especificando seu nome. Agora, vou executar o
contêiner novamente, mas agora no modo desanexado especificado através
da opção menos d. Manterei o aplicativo da web com o
mesmo nome e ele será
baseado na mesma imagem. Vou validar meu trabalho através do uso do comando pause
band ps, que nos mostrará todos os contêineres
em execução. E podemos ver que nosso
contêiner chamado Web App, que foi criado há
dois segundos, está funcionando. Obterei
informações detalhadas sobre este contêiner por meio
do uso de registros do Pac-Man. E podemos ver alguns registros associados ao nosso contêiner de aplicativos
da web. Agora, deixe-me
limpar a tela. E agora vamos usar
o
comando stop Pokémon para parar com
um contêiner de aplicativo da web. Podemos validar nosso
trabalho através do uso
do old man ps menos
um comando onde podemos verificar o status
do contêiner e ele mudou de up para exit. Iniciarei o contêiner novamente usando o comando boatman
start. E como você pode ver, o status mudou
novamente de encerrado para ativo. Então, agora eu gostaria de
demonstrar o comando
Pac-Man cp. Mas antes disso, criarei um documento chamado index.html com o conteúdo do
helloworld usando o comando echo e o redirecionamento de
saída, depois usarei o comando
port man cp, especificando o arquivo index.html que eu criei anteriormente. E eu vou
transferi-lo para o contêiner chamado wet-bulb dentro do
passado slash var slash v, V, v slash HTML
slash index.html. Agora, vou entrar no contêiner
usando o
comando boatman exec com as
opções menos IT slash bin slash bash. Como você pode ver, o
lote mudou e, executando um comando P
S menos ox, posso ver claramente que não estou
mais no meu host local. Estou dentro do contêiner. Vou mudar o
diretório para o caminho HTML da barra var barra VB barra. E aqui eu posso fazer uma lista. Dentro dessa lista,
podemos
ver claramente o arquivo index.html. E vou apenas ler o
conteúdo desse arquivo, que é exatamente como
especificado. Olá mundo. Copiamos com sucesso
nosso arquivo de dentro do host local para o contêiner
no caminho especificado. Se eu quisesse verificar
o conteúdo
desse arquivo sem
entrar no contêiner, posso fazer isso
usando o comando pod man exec para executar o comando cat no
caminho especificado. Então, agora é hora de nos
limparmos. Primeiro, listarei
todos os contêineres com o pod man ps menos um comando, e podemos ver claramente nosso contêiner de aplicativo
da web lá. Em seguida, vou parar
o contêiner com o comando Pokemon stop
web app. Depois,
removerei o contêiner com o comando port man RM. Em seguida, listarei todas as
imagens presentes no meu host local usando o comando
Pokemon images, removerei minha imagem
existente com o comando pot man RMI. E vou listar novamente todas as imagens com o comando
Pokemon images. E podemos ver claramente
que não temos imagens. E usando o comando pod
man ps minus a, também
podemos
ver claramente que
não há mais
contêineres em execução neste momento. Então, parabéns. Agora você tem uma
compreensão básica de como gerenciar serviços em
contêineres usando a ferramenta de
gerenciamento de contêineres do port man. Vejo você no próximo módulo,
onde falaremos sobre o gerenciamento de imagens de contêineres.
5. Como gerenciar imagens: No
módulo anterior, falamos sobre gerenciamento de contêineres. Agora, vamos ver também
maneiras pelas quais podemos
gerenciar imagens em nosso ambiente. Então, sem mais delongas,
vamos começar. Agora, vamos dar uma olhada em alguns comandos
essenciais para gerenciar imagens dentro de carteiros. Nós vimos anteriormente uma piscina masculina
derramada. Agora, usando o comando port
man poor, podemos salvar uma imagem de contêiner
localmente a partir de um repositório. Podemos listar todas as imagens do contêiner
usando as imagens do homem da panela. E se quisermos
remover uma imagem salva localmente, podemos usar o comando pod man RMI especificando
o nome da imagem. Agora vamos supor que
gostaríamos de renomear uma imagem. Podemos fazer isso usando
o comando Pac-Man tag, especificando o nome da imagem
original e o novo nome da imagem. Gostaríamos de dar.
Se quisermos fazer upload uma
imagem de contêiner segura localmente para um registro, podemos fazer isso usando
o comando push do Pac-Man. Se quisermos obter informações
detalhadas
sobre uma imagem de
contêiner armazenada localmente, conforme discutido anteriormente,
podemos fazer isso usando o comando pot man
inspect. Agora vamos supor que trabalhamos em um contêiner como um servidor web
HTTP. E modificamos nosso arquivo
index.html e gostaríamos de criar uma nova imagem com base
nesse contêiner alterado. Podemos fazer isso usando
o comando
pod men commit para criar uma imagem a
partir de um contêiner em execução. Agora que temos
uma visão geral de todos os comandos importantes
para gerenciamento de imagens, vamos para a demonstração. Primeiro, usarei a pesquisa do
port man para encontrar uma imagem HTTPD adequada. Vou rolar para cima
dentro dos resultados. E, novamente, copiarei
o primeiro resultado, que é HTTP D24 RHEL sete. Eu limparia a tela e agora usarei o pool Pac-Man para baixar
essa imagem
do repositório e
salvá-la localmente. Agora, vamos esperar um pouco para o puxão seja finalizado. Então, agora que o
download está completo, posso usar
imagens do Pac-Man para validar se a imagem
foi bem-sucedida. E podemos ver isso aqui. Agora, vou usar o
inspetor do port man para inspecionar a imagem. Como você pode ver, o Pokémon
expect nos fornece informações
detalhadas sobre
essa imagem em particular. Podemos ver o usuário sob o
qual a imagem está sendo executada. Podemos ver as portas expostas. Você pode ver um resumo do que a imagem pretende fazer, uma descrição detalhada sobre isso. Agora, eu gostaria de retrair a imagem usando o comando
boatman tag, especificando o nome da
imagem original e a nova tag que vou dar a ela será
chamada de minha nova tag versão 2. Eu posso construí-lo trabalhando usando as imagens de Pokémon Comando N. Podemos ver claramente aqui localhost slash
minute tag versão 2. Agora vou usar o contêiner de comando port man run em
execução no modo desanexado. O contêiner será chamado de aplicativo
da web e será
baseado na imagem chamada tag de
minuto versão 2. Como você pode ver, o contêiner
foi criado com sucesso. E agora vou executar
o comando Pac-Man ps menos um para validar
se ele está funcionando. E o que você sabe que está
funcionando adequadamente? Em seguida, abrirei um terminal
dentro do contêiner usando o comando pot man exact minus IT
slash bin slash bash. Lá, farei um teste de eco e redirecionarei a saída
para o arquivo
slash var slash slash HTML slash
index.html. Dentro desse contêiner,
vou sair do contêiner. Vou executar o Pac-Man ps menos a. Novamente, podemos ver que
ele está funcionando. E vou usar o comando
chamado Pac-Man commit para criar uma imagem com base neste contêiner alterado, pod men commit web
app, minha nova imagem, versão 1, podemos ver que a imagem foi
criado com sucesso. Pararei o
contêiner existente chamado mapa da web e o removerei usando
o comando rm poor man. Vou limpar a tela. E agora vou criar
um novo contêiner em
execução no modo desanexado
com o mesmo nome, mas agora com base
na imagem confirmada que
criamos anteriormente, o contêiner foi criado
com sucesso e agora vou usar o comando
pot man exec para executar um comando cat dentro do contêiner para ver se
o arquivo está presente. Barras de barra de gato como v,
V, v barra HTML barra index.html. E podemos
ver claramente que o resultado é o esperado nos testes do Sul, então funcionou perfeitamente. Agora, vou usar
o
comando Pokémon stop para interromper o contêiner do meu aplicativo
da web. Vou removê-lo usando
o comando pod man RM. Agora estarei executando o comando
Pac-Man images para listar todas as imagens salvas no
meu sistema de arquivos local. E vou remover
cada um deles com o comando Pokemon RMI. Então, homem orgulhoso, RMI, imagem
minuto versão
1, homem da panela, RMI, minha nova tag 2 e pobre homem RMI registry dot
access, ambos Red Hat.com, podemos validar
que nossos sistemas, ele é limpo por executando o comando
pot man images e o departamento ps menos um comando e não há mais nada lá. Parabéns, agora você tem uma compreensão básica
de como gerenciar imagens de
contêiner usando a ferramenta de
gerenciamento de contêineres Pac-Man. Vejo você no próximo módulo em
que falaremos sobre armazenamento efêmero e
persistente.
6. Armazenamento persistente: Olá e bem-vindo de volta. Neste módulo, falaremos
sobre armazenamento de contêineres e aprenderemos como montar armazenamento
persistente dentro de contêineres. Porque, por padrão, os contêineres
têm armazenamento efêmero. Então isso significa que
tudo o que fizemos dentro um contêiner no momento
da destruição, desapareceu. Então, vamos ao que interessa. Portanto, o armazenamento que o contêiner
usa é efêmero. A natureza efêmera
do armazenamento de contêineres significa que seu conteúdo
é perdido depois que você remove o contêiner, montando um diretório do host
dentro do contêiner, você está fornecendo o contêiner.
armazenamento persistente. Todas as alterações e conteúdos
do diretório montado serão gravados no sistema de arquivos host. Assim, eles persistirão depois que o contêiner for
destruído ou removido. Lembre-se de que
você deve levar em consideração
as permissões do sistema de arquivos ao montar
um volume persistente para o contêiner usar. Agora, a ferramenta de
gerenciamento de contêiner Pokémon oferece suporte contêineres
sem raiz se você
estiver executando o contêiner como a raiz do usuário
do host, então o UID e o GID corresponderão àqueles
dentro do contêiner. Em um contêiner sem raiz, usuário tem acesso root
dentro do contêiner porque o pod man cria o contêiner
dentro do namespace do usuário, o usuário raiz do
contêiner mapeia para o UID do usuário.
dentro da máquina host. Cada usuário depois de dentro
do contêiner mapeia para um usuário dentro do intervalo de
100 mil. Então, agora vamos dar uma olhada em
alguns comandos úteis para montar o
armazenamento persistente em contêineres. Com o mapa UID Padma unshare cat slash proc slash slash. Podemos ver esse mapeamento UID de usuários dentro do contêiner. Nós deportamos homem, unshare cat
slash proc slash slash mapa JD. Podemos ver esse mapeamento GID. Agora, se quisermos montar o armazenamento
persistente
dentro de um contêiner, usaremos
o
comando pod man run com a opção menos v. O primeiro comando cria um servidor web HTTP onde o conteúdo é obtido
do diretório montado (
barra), o conteúdo da web no
host é montado na var, barra, www), barra,
ponto, barra, caminho HTML dentro do contêiner. Adicionar um Z maiúsculo no final
do caminho
também garantirá que você esteja definindo o contexto correto do SE Linux. Agora, vamos à demonstração e tornar as coisas um
pouco mais práticas. Então, vamos começar esta
demonstração examinando primeiro os
mapeamentos GID e UID usando o comando pod
man unshare. Pod man, descompartilhe cat slash, proc slash, corte seu mapa de identificação. E podemos ver os
mapeamentos aqui. E Birdman unshare cat slash
proc slash tamanho da célula JID. E podemos ver os mapeamentos
GID aqui. Agora que temos isso, vamos criar
um novo caminho. Vou criar um
diretório chamado
conteúdo da web na
casa do meu usuário. Dentro desta pasta, vou
ecoar a mensagem montada IN e redirecionarei
a saída para um arquivo chamado index.html. Agora vou limpar a
tela e vamos ver quais imagens temos disponíveis usando o comando Pac-Man
images. Não temos nenhum. Portanto, usarei o comando pod man
pull para baixar uma imagem de um servidor
HTTP localmente. E vamos esperar um pouco até que
a imagem termine de baixar. O
download da imagem foi concluído com êxito. E podemos usar o comando pod
man run
para criar um contêiner
chamado Web App. Ele será executado no modo
desanexado e eu
estarei montando o
diretório de conteúdo da web que eu criei anteriormente do meu
host para a pasta HTML slash var slash
www barra
dentro do contêiner, mantendo os contextos
corretos do SELinux. Ao adicionar o
Z maiúsculo no final, vincularei a porta
através da opção menos p. Portanto, a porta 8082 do host
será vinculada à porta 8080
do contêiner. E vou usar a imagem que baixei
anteriormente. Como podemos ver usando o comando
pod man ps minus a, o contêiner está
funcionando e a porta
está delimitada corretamente. Se eu fizer um comando curl
no host local
por meio da porta 8082, poderemos ver a mensagem,
Eu sou Mountain. Agora vou usar o comando boatman
exec para obter um terminal N dentro
do contêiner e vou ecoar uma nova mensagem. Esta mensagem significa que fui modificado e vou gerar
a saída padrão, o arquivo que montamos
dentro do contêiner. Então, index.html. Vou sair do contêiner
usando o comando exit e agora vou ler o arquivo dos pontos
de montagem,
portanto, do conteúdo da web. E podemos ver que ambos os valores
estão montados e eu modifiquei. Se eu usar o comando curl, podemos ver a mesma saída. Agora, vou parar o
contêiner e
removerei o contêiner usando
o comando pod man RM. E vou recriá-lo apenas para ver a natureza do armazenamento
persistente. Então, vamos testar isso
executando um comando curl no host local na porta 8082. Como você pode ver, a mensagem
permaneceu inalterada. Isso ocorre porque o armazenamento desse contêiner específico para esse caminho específico é
mantido no host local. Portanto, mesmo que o
contêiner tenha sido destruído, o que foi escrito
no diretório de conteúdo da web
permaneceu persistente. Muito obrigado
e nos vemos
no próximo módulo,
onde
falaremos sobre vinculação de portas.
7. Vinculação de portas: Olá e bem-vindo de volta. No módulo anterior,
falamos sobre o armazenamento efêmero
e o armazenamento persistente, e aprendemos como dar aos
contêineres armazenamento persistente, que não percamos nada
quando eles são destruídos. Dentro deste módulo,
falaremos sobre vinculação de portas
e como vincular as portas do host local
aos pontos de contêiner para torná-los acessíveis de
fora também. Então, vamos ao que interessa. O que é vinculação de porta de contêiner? Bem, conectar-se a um
contêiner significa que os clientes devem conectar
duas portas do host que enviarão tráfego para os esportes de contêiner ou para as portas expostas aos
contêineres. Podemos mapear portas do host para aquelas acessíveis de
dentro do contêiner, para tornar os contêineres acessíveis
de fora também, não apenas do host local. Lembre-se de que, se
você quiser torná-los acessíveis de
fora também, também precisamos verificar as regras de
firewall para garantir que qualquer tráfego
nessas portas seja permitido. Então, com isso em
mente, vamos dar uma olhada em alguns comandos essenciais
para fazer a ligação da porta do contêiner. Agora, para vincular uma porta do host local
ao contêiner, usaremos
o
comando pod man run com a opção minus p. Nosso primeiro exemplo cria um
servidor web HTTPD em contêiner chamado web app, onde todo o tráfego da
porta 8082 do host é passado para a porta
8080 do contêiner. Lembre-se de que o contêiner deve aceitar tráfego nessa porta. Isso significa que ele tem que ser exposto. E podemos ver que
usando o comando pot man in spec na imagem
do contêiner, usando a
porta portmanteau menos um comando, podemos ver todos os mapeamentos de portas. E usando o comando pod man port especificando o nome do
contêiner, podemos ver o mapeamento de portas
para um contêiner de nome. Não se esqueça de
criar uma regra de
firewall persistente usando o comando firewall CMD para
permitir o tráfego nessa porta. Agora que você tem uma boa visão geral
teórica do que é o mapeamento de
portas e sua função no
Container Management. Vamos para a demonstração. Primeiro, usarei
o
comando Pokemon images para mostrar que tenho uma imagem de
contêiner HTTPD salva localmente presente. Em seguida, usarei o comando port
man run para criar um contêiner chamado web app running
and detached mode, que encaminhará todo o
tráfego da porta 8082 do lado do host para a porta
8080 em o lado do recipiente. Como podemos ver através do
pod man ps menos um comando, o contêiner está instalado e funcionando. Agora vou usar um comando executivo do
homem orgulhoso com a opção menos i t
para obter um terminal ativo
dentro do contêiner. Aqui, vou ecoar a
mensagem hello world e redirecionarei a
saída para o arquivo slash var slash www slash HTML slash
index.html. Em seguida, vou sair do contêiner
com o comando exit. Agora usaremos
o comando port man port minus a para ver
todos os mapeamentos de portas. E podemos
ver claramente que o tráfego do host local na porta 8082 é redirecionado para a porta
8080 do contêiner. Também podemos ver isso
usando o comando port man port especificando
o nome web app. Agora vamos testar isso
usando um comando curl e chamaremos o host
local na porta 8082. E podemos ver claramente
a mensagem helloworld. Então funcionou perfeitamente. Agora, para tornar o tráfego acessível de fora
do host local, também
adicionarei uma regra de
firewall para
permitir o
tráfego na porta 8082. Está me pedindo privilégios
administrativos. Eu darei a eles e
foi um sucesso. Portanto, agora nosso servidor
web
Apache em contêiner pode ser acessado tanto do host local quanto fora do
host local na porta 8082. Também podemos ver
a ligação de portas, mesmo se executarmos um Pokémon
ps menos um comando, podemos ver claramente aqui que o
tráfego do host local é redirecionado para a porta 8080 slash
TCP no lado do contêiner. Agora, como eu sei que
devo fazer diretamente para a porta 8080 no lado do
contêiner, é
aqui que o Pokémon
inspect entra em jogo. Podemos inspecionar a imagem do contêiner localmente
seguro e
observaremos as portas expostas. As portas expostas são, na verdade o que está acessível
ao contêiner. De onde ele permite
o tráfego? Então foi assim que eu
soube que a porta 8080 era para onde eu deveria redirecionar
o tráfego da porta 8082. Agora tudo o que resta é
limpar depois de nós mesmos, nosso aplicativo web stop the container
com o comando man stop. Em seguida, vou removê-lo com
o comando Pokemon RM. E por último,
removerei a imagem com o comando Pokemon RMI. Muito obrigado
e até
o próximo módulo
em que falaremos sobre Rede de
Contêineres.
8. Rede de contêineres: Olá e bem-vindo de volta. No módulo anterior,
falamos um pouco sobre mapeamento de portas e vinculação de uma porta de host a uma porta exposta de
contêineres. Agora vamos nos aprofundar mais
com a Rede de Contêineres. Veremos a
capacidade do pobre homem de criar redes e resolver nomes
dentro dessas redes. Então, sem mais delongas,
vamos começar. Agora, vamos dar uma olhada em alguns pontos
essenciais
para a Rede de Contêineres. O comando importante aqui é a rede de
ambos os homens com o comando
postman network create. Podemos criar uma rede especificando seu nome de gateway e sub-rede. O pobre homem inspecionar a rede
especificando um nome de rede, podemos obter detalhes
sobre uma rede existente. Nós deportamos man network creates especificando um nome de contêiner. Podemos conectar o contêiner
a uma rede existente. Nós deportamos a rede man removida. Podemos remover uma rede
existente e deportar o comando man run. Podemos adicionar a opção de rede
menos menos e conectar o contêiner a
uma rede após a criação. Agora que temos
uma boa visão geral dos comandos
importantes relacionados
ao Container Networking, vamos para a demonstração. Agora, para iniciar esta demonstração,
usarei o comando port man
images para mostrar minha imagem de contêiner
HTTPD salva localmente. Agora vou usar o comando de
busca do pobre homem para procurar uma oitava imagem do Red Hat Enterprise
Linux. Eu copiei e
agora vou usar os comandos do post man Paul
para baixá-lo localmente. Então, vamos esperar um pouco para
que o download seja concluído. Agora vou usar o
comando
poor man network create para criar uma
rede para meus contêineres. A sub-rede será
especificada por meio da opção menos menos sub-rede e será 192168
ponto um ponto 0 barra 24. E o gateway
será especificado por meio da opção de
gateway menos-menos, e será 192168
ponto um, ponto um. O nome da minha rede
será minha rede. Agora que a rede
foi criada com sucesso, podemos prosseguir para a criação dos
meus serviços em contêineres. Primeiro, usarei o comando Pac-Man
run para criar um contêiner chamado cliente em
execução no modo desconectado, conectado à minha rede por meio da opção de rede minus-minus
com armazenamento persistente. E a imagem base por trás
desse contêiner será a imagem de oito bases do Red Hat Enterprise
Linux. Como você pode ver, o
contêiner foi criado
com sucesso e
listarei ou executarei contêineres com o Pokémon ps menos uma opção, e ele está funcionando. Em seguida, criarei meu segundo serviço em
contêiner usando o comando Pokémon run. Este será um
servidor web Apache chamado servidor web, rodando em modo
desconectado, conectado também à minha rede. Ele usará a imagem register.access.com
http D24 L7, que eu armazenei localmente. Esse segundo contêiner
também foi criado com sucesso. Podemos vê-los
funcionando e funcionando. Agora, usarei o comando pod
man network ls para ver todas as nossas redes
disponíveis. E podemos
ver claramente minha rede aqui. E para obter
informações mais detalhadas sobre minha rede, usarei o
comando postman
network inspect especificando o
nome da minha rede. E podemos ver aqui
a sub-rede e o gateway. Agora que temos
uma boa visão geral de nossa rede
e de nossos contêineres, vamos ver se tudo funciona. Usarei o comando port
man exec com a opção minus IT para abrir um terminal dentro do contêiner do servidor
web. Aqui vou usar o comando
echo e redirecionar sua saída para
o arquivo slash var slash www slash HTML slash
index.html. Para criar uma mensagem
personalizada. Mais especificamente, olá,
vou sair deste contêiner e agora vou entrar no outro contêiner,
o contêiner do cliente, novamente com o pot man isento
menos a opção de TI para obter um terminal dentro
do cliente que está executando o Red Hat
Enterprise Linux oito. Aqui vou usar o comando
curl para enrolar o servidor web
na porta 8080, que foi a exposta. E podemos ver claramente que
a mensagem é a esperada. Então, parabéns,
criamos dois contêineres. Um rodando em um servidor web
Apache conteinerizado executando o Red Hat
Enterprise Linux oito, criamos uma rede entre os dois e podemos ver que eles
se comunicam e também
nomearam resolução do servidor. Muito obrigado
e nos vemos
no próximo e último módulo.
9. Como criar imagens: Bem-vindo ao
módulo final do nosso curso. Aqui, aprenderemos como criar imagens de
contêiner a partir de
arquivos para nos ajudar a criar nossas próprias imagens personalizadas e personalizá-las de
acordo com nossas próprias necessidades. Então, sem mais delongas,
vamos começar. Primeiro, falaremos
sobre as etapas
para a construção de uma imagem de contêiner. Para que o Birdman possa criar imagens automaticamente lendo as
etapas de um arquivo Docker, você pode perguntar o que
é um arquivo Docker? Um arquivo Docker é um
documento de texto que contém todos os comandos que
um usuário pode chamar para montar uma imagem. Agora, os arquivos do Docker também
facilitam a criação de novas imagens de contêiner
com base em uma existente, como estender uma largura de imagem de
contêiner
Enterprise Linux classificada largura de imagem de
contêiner
Enterprise Linux e a funcionalidade HTTPD. Então, vamos seguir em frente
e ver como
realmente criamos uma imagem de
contêiner. Primeiro, crie um diretório
de trabalho que contenha todos os arquivos necessários para criar a imagem do
contêiner. Em seguida, criamos um arquivo Docker. Um arquivo Docker é apenas um documento de
texto que contém todos os comandos que
um usuário pode chamar para montar uma imagem. E por último, usamos o comando depots
man build. Usamos o
comando build Poll Man para criar
a imagem com base
no arquivo docker e
outros recursos dentro do diretório de trabalho. Então, agora vamos dar
uma olhada em um exemplo do Dockerfile e
ver nossas possibilidades. Agora, aqui temos um Dockerfile
simples. O campo de indica qual imagem
de Bates deve ser estendida. O campo label indica qual rótulo essa imagem de
contêiner terá. O Rosenfield executa comandos
dentro da imagem base, o campo exposto expõe
as portas do lado do contêiner. O campo EM define variáveis
ambientais
dentro do contêiner. O campo de cópia copia
do diretório de trabalho
para o contêiner. O campo de usuário define o usuário
sob o qual o contêiner é executado, pois o campo de adição é
semelhante ao campo de cópia. O campo do ponto de entrada diz o comando com o qual o
contêiner começa. E podemos criar o
contêiner analisando esse arquivo Docker com o comando
pod men build. Então, vamos colocar todo
esse conhecimento em prática, passando
para a demonstração. Agora vou começar
esta demonstração listando o conteúdo do meu diretório
de trabalho. Eu tenho um
arquivo index.html que contém a
mensagem hello world e um arquivo Docker pré-fabricado
que eu montei anteriormente. Vamos dar uma olhada nisso. Portanto, ele estende a imagem sete do Red Hat
Enterprise Linux, o usuário sob o qual o
contêiner está sendo executado como root. Ele executa uma instalação yum
menos y HTTPD. Para instalar o serviço HTTPD, ele expõe a porta 80 e
copia
o arquivo index.html do diretório
de trabalho para o contêiner barra var barra
barra HTML index.html caminho. Agora, vou usar
o
comando port man build para criar minha imagem. Estou especificando a opção
menos d para tag, que dará à mãe minha imagem, o nome da minha imagem HTTPD. Agora, vou usar o comando Pac-Man images para ver se
a imagem foi criada. E podemos ver isso aqui, localhost corta minha imagem HTTPD. Agora vamos fazer um teste. Usarei o comando pot
man run especificando que o contêiner
será executado no modo desanexado. O nome do meu contêiner
será Web App. Estarei encaminhando a porta 8082 para a porta 80
do contêiner e usarei
minha própria imagem criada. O contêiner
parece estar funcionando. O encaminhamento de porta
parece funcionar. Então, vamos fazer uma ondulação no host
local na porta 8082, e podemos ver claramente
a mensagem hello world. Portanto, o arquivo foi
copiado com sucesso. Vamos entrar no contêiner
com as opções Pac-Man exec menos i t para abrir um terminal
dentro do contêiner. Como você pode ver, o terminal
foi aberto como root. Portanto, o usuário que
eu especifico
no arquivo Docker é
usado e o arquivo que copiamos
do host local para o contêiner está presente. Então, o arquivo do Docker
fez o prometido. Temos um sistema
operacional Red
Hat Enterprise Linux seven em contêiner rodando
no serviço HTTPD. Ao finalizar esta demonstração, também
concluímos nosso curso intensivo sobre gerenciamento de
contêineres. Gostaria de agradecer por sua participação e talvez nos
vejamos em
outros cursos futuros. Muito obrigado.
Andrei Balint
