Transcrições
1. Apresentação: Bem vindos de volta, pessoal. Nesta seção,
começaremos a analisar os
contêineres na nuvem
ou nos contêineres do Azure. Portanto, nesta seção,
aprenderemos sobre conteinerização
e
veremos mais sombrio o que é, como podemos configurá-la
e usá-la localmente. E então veremos como podemos
colocar em contêineres ou
dotnet o projeto Core. E então, como hospedamos usando o serviço Container Instances fornecido pela Microsoft
como um todo, podemos hospedar nossa imagem de contêiner usando o Azure Container Registry. E analisaremos o Kubernetes. Saiba se esta é sua primeira vez na conteinerização,
não se preocupe, essa é uma visão geral, mas vamos
analisá-la o suficiente para que você se sinta confiante para
conversar sobre isso. Obviamente, este não é
um curso aprofundado sobre conteinerização. Você pode conferir meu curso
completo sobre isso. Mas nesta seção,
teremos uma visão geral de todo o fim de semana, transferindo nossos contêineres de nosso ambiente local para
nossos ambientes em nuvem. Portanto, fique ligado. Eu sei que você vai se divertir.
2. O que são recipientes?: Agora, antes de entrarmos em
nossos contêineres zero, basta
ver os contêineres o que são
e por que os usamos. De acordo com um contêiner,
é uma unidade padrão de software que empacota o código
e todas as suas dependências. O aplicativo é executado de forma rápida, confiável e em qualquer ambiente. E é isso que eu
parafraseio, o que está escrito, mas essa é a explicação
e vem do docker.com. Não. Por que precisamos de contêineres? E isso é um chavão. Você ouviria falar
sobre contêineres e conteinerização e por que
devemos mudar para eles. Vamos examinar quais são
os problemas existentes e
como os contêineres podem nos ajudar. Não há problemas ao
desenvolver software. A
virtualização tem um custo. Então, estávamos saindo de
uma seção em que analisamos as máquinas
virtuais na nuvem
e a infraestrutura como um serviço. A realidade é
que, e tenho certeza todo desenvolvedor pode
atestar o fato de que, quando você tem um
ambiente e está tentando desenvolver
nesse ambiente, precisará de máquinas
virtuais, certo? Portanto, a organização
pode não comprar uma máquina por software
que você tem. Em vez disso, eles
vão prosseguir e provisionar uma máquina virtual. Cada máquina virtual
precisa ter um sistema operacional, o que significa que são necessárias mais
licenças para cada
máquina virtual e, em seguida, para qualquer software
de
suporte necessário para seu aplicativo específico em sua máquina virtual ou em um
conjunto de máquinas virtuais. Esses são outros custos de licenciamento. Portanto, é preciso
considerar o fato de que virtualização não é um empreendimento
barato, especialmente quando é feita
internamente. Também temos o desafio das diferenças nos ambientes,
porque quando
provisionamos uma máquina virtual e instalamos uma
versão específica do software, versão do sistema
operacional
nessa máquina
ou máquina virtual específica. Em vez disso, esse ambiente é
configurado de uma maneira específica, então é muito
difícil, não muito, mas significativamente
difícil replicar esse ambiente exatamente para Q0. E então, pela Accenture em produção, o que encontramos
como desenvolvedores é
uma situação em que
ela funciona no Dove
e, em seguida, há uma
pequena diferença de versão entre dev e QA. Ele quebra em q0 e, mesmo
quando corrigimos a fila, não
funciona
imediatamente no prod. Portanto, sempre haverá pequenas diferenças entre
os diferentes ambientes. E isso pode causar,
eu queria dizer, cabeça
desnecessárias para nós como desenvolvedores e
até mesmo para a infraestrutura. Eu sou praticante, eu sei. Outra coisa é quão fácil
é para você mudar
seu sistema operacional? Porque quando você configura um
aplicativo para dotnet core, você precisará do IIS, você precisará de
determinados softwares de
suporte de hospedagem baseados em nosso Windows Server. Mas então, se você precisar mudar
para um servidor Linux, então você deve considerar, ok, você precisa usar em genética ou
Apache ou algum outro software de
hospedagem, alguma outra versão disso, alguma outra versão daquela. E é, é
difícil replicar o
ambiente em execução no Windows para outro, outro sistema
operacional. Então, esses são alguns
dos problemas que
enfrentamos ao desenvolver software, especialmente software que
queremos executar em qualquer plataforma. Não há benefícios de usar contêineres. Primeiro, temos portabilidade. Portanto, o Docker criou
um padrão industrial para contêineres para que eles
possam ser portáteis em qualquer lugar. E eu vou falar mais sobre
o que a habilidade de portas realmente significa. Os contêineres também são leves, então eles compartilham o kernel do sistema
operacional das máquinas subjacentes. Você não precisa provisionar um novo sistema operacional por aplicativo, a virtualização
on-line, que cada máquina virtual tem suas próprias máquinas autohospedadas e totalmente provisionadas, por assim dizer. contêineres ficam em cima de
um sistema operacional, mas fornecem um ambiente
virtual no qual somente o software
necessário para o ambiente
pode ser instalado. E então, por extensão, devido à capacidade das portas, uma vez que temos esse modelo, que chamamos de imagem de contêiner, podemos provisioná-lo em
cima de um sistema operacional Windows,
Linux ou macOS e sempre obter os
mesmos resultados. Também há a
questão da segurança. Agora, quando um aplicativo
está em um contêiner, ele é seguro porque você sempre
pode usá-lo. Você pode levantá-lo novamente deslocado. E sempre podemos armazenar
nossos segredos para que ninguém a quem possamos restringir
o acesso ao conteúdo seja um pouco mais fácil do que faríamos
em uma máquina virtual. Também analisaremos a imutabilidade. Portanto, uma imagem que
é o modelo de um contêiner sempre será
a mesma quando for criada. Então, mais uma vez, isso
remete à portabilidade, porque se houver uma imagem de contêiner
para meu aplicativo e ela precisar de três
bibliotecas para suporte, ela sempre
me fornecerá esse ambiente. Não importa onde
seja provisionado. Portanto, posso ter certeza de que,
uma vez colocado em contêineres
, sempre será o mesmo. Se houver uma nova
versão, eu
teria que criar uma
imagem totalmente nova com essa nova versão. Nesse ponto, você
tem uma imagem para a versão um e uma
imagem para a versão dois. A versão um nunca
atualizará a versão dois. Portanto, você não quer
correr o risco de provisionar a versão errada porque está claro qual versão você
vai provisionar. Agora, aqui está uma visão geral
de toda a aparência do Docker, extraída da documentação da
Microsoft. Então, no lado esquerdo, você vê que temos
os sistemas operacionais. Pode ser Linux,
pode ser Windows,
pode ser Engine X igual a
B Mac OS ou o que quer que seja, qualquer que seja o kernel
subjacente. Portanto, a esquerda. O Docker Engine
está acima disso e
nos fornece um servidor, um cliente e uma API RESTful. E tudo isso funciona
em conjunto para gerenciar as imagens que são criadas. Então, mais uma vez, a
imagem é o modelo. E usando esse modelo
e o servidor Docker, podemos provisionar em contêineres, que você verá
na extremidade direita. Portanto, o contêiner é a instanciação
real do modelo. E então esse modelo pode
ser reproduzido várias vezes. Portanto, podemos ter
vários contêineres fora do mesmo aplicativo
por diferentes motivos. Então, mais uma vez, a imagem
são apenas os modelos. O contêiner é a
instanciação desse modelo. Agora eu mencionei o
mais escuro várias vezes. Portanto, o Docker é uma plataforma
de
conteinerização usada para desenvolver, enviar e operar contêineres. O Docker não
usa um hipervisor. Então, ao contrário das máquinas virtuais, você não precisa de um hipervisor, então você pode realmente
instalá-lo em seu desktop ou laptop se estiver desenvolvendo
e testando aplicativos. E o melhor de tudo é que ele suporta todos os principais sistemas
operacionais. Portanto, independentemente do
sistema operacional que você está usando, há suporte do Docker para ele. E ele suporta cargas
de trabalho de produção para muitas variantes das versões Linux e
Windows Server. O melhor de tudo é que ele é suportado por muitos provedores de nuvem,
incluindo o Microsoft Azure. Agora você também verá, ao
pesquisar o Docker, o Docker Hub. Portanto, o Docker Hub é uma oferta de software como serviço que
é um registro de contêineres. Essencialmente, um
registro de contêiner armazena e distribui as imagens de contêiner que
criamos usando o Docker Hub. Docker hub, desculpe,
você pode realmente hospedar a imagem para seu aplicativo
e distribuí-la. E apoia a
distribuição pública em ambos. Ele também oferece suporte à distribuição
privada. Portanto, mesmo dentro da
sua organização, forneça imagens internas de
aplicativos que você está mantendo. Você pode confiar no Docker
Hub para ter privacidade, mas também para hospedagem. Agora, quando analisamos nossos
zero contêineres e ofertas
de serviços,
temos as Instâncias de Contêiner do Azure. As Instâncias de Contêiner
do Azure nos permitem o Senhor e executamos
imagens de docker sob demanda. Isso nos permite recuperar
uma imagem de um registro como o Docker Hub ou o
Azure Container Registry. Então, isso nos leva ao
Azure Container Registry. Este é um serviço de registro
gerenciado do Docker baseado no registro do Docker,
o registro Open Source
do Docker para o qual apontar. E, claro, isso é
gerenciado pela Microsoft que você não precise
se preocupar com as versões. Esse é apenas o padrão
atual. E isso nos oferece uma oferta de
registro privado hospedada no Azure. E permite que você crie, armazene e gerencie suas imagens não gerenciadas,
infelizmente, para todos os
contêineres e para implantações. Portanto, entre as Instâncias de
Contêiner do Azure como seu Registro de Contêineres, você tem uma boa base para começar conteinerizar seus aplicativos e armazenar as diferentes
versões das imagens. E, mais uma vez, tudo isso
pode ser feito de forma privada. Assim, você pode acelerar
seus esforços de desenvolvimento, reduzir seus custos de
infraestrutura e maximizar seu aplicativo na entrega usando a
conteinerização. Quando
voltarmos,
começaremos olhando para um buraco mais escuro. Podemos configurá-lo e como
podemos criar nossos primeiros contêineres. Então fique por aqui.
3. Docker de configuração: Agora vamos
começar a
configurar o Darker em nossa máquina e nossa jornada
começa em docker.com. Assim, em seu
navegador, acesse docker.com
e, a partir daqui, você pode baixar o Docker
Client apropriado para sua máquina. Então, estou usando uma máquina Windows, mas você vê que
pode obter um chip ascendente, chip
Linux e Intel para
outros tipos de máquinas que talvez não sejam baseados
nesses sistemas operacionais. Portanto, você pode instalá-lo com base em como
precisa ser instalado em
sua máquina específica. Se
estiver usando a versão do
Windows, é fácil
instalá-lo usando o assistente. E uma vez instalado, você será levado a instalar o subsistema Windows Linux ou o subsistema Windows para Linux,
WSL, que
mencionamos anteriormente. Portanto, está na
documentação da Microsoft. Se você apenas pesquisar no Google Windows, WSL, verá esta documentação aparecer e poderá
seguir as instruções. Portanto, você pode simplesmente executar
isso usando seu prompt
parcial ou de comando como administrador. E ele fará
o download e instalará
isso para você. Agora, depois de instalar o Docker e o Subsistema Windows
para Linux
, você pode iniciar
o Docker Desktop. Então isso pode demorar um pouco. Eu já o tenho instalado. Você pode ver que estou
mesmo pendente ou
não , mas você pode clicar em pausa, certifique-se de ter tudo
configurado antes de continuar. E quando você fizer isso, poderá iniciar
seu Docker Desktop. A partir daqui. Você pode ver
os contêineres. Se for a primeira vez que
você está executando o Docker, então você não terá nenhum contêiner nessa lista. Você também pode ver as imagens. Então, a partir daqui, você pode realmente
ver imagens locais versus imagens que estão
disponíveis no hub. Então, mencionamos o Docker
Hub na lição anterior. Então, o que você quer fazer
é no seu navegador, acessar hub.docker.com e criar um ícone. Estou dizendo que
vou dizer não, só para mostrar
o que você pode esperar. E então você pode
começar hoje de graça. E depois de ter seus cones, você pode acessar as
diferentes imagens do docker que são disponibilizadas
para consumo público. Não. Estou dizendo que estou
enviando de volta aqui, estou examinando meu
próprio registro, onde
tenho a
imagem do banco de dados de um paciente que eu criei. Está disponível para o público. Não é muito útil. Na verdade, criei este para meu livro sobre
desenvolvimento de microsserviços, onde demonstrei como você pode diferentes partes do
seu aplicativo de microsserviços em
contêineres para
que você
possa pegar uma cópia desse livro, se quiser,
do ponto de vista dos microsserviços. Mas a questão é que,
a partir do Docker Hub, posso ver
diferentes registros. Então, esses são meus repositórios, mas se eu clicar em Explorar, poderei ver imagens
diferentes e
você verá que há vários milhares de
imagens disponíveis para uso. Então eu posso usar qualquer um desses. Talvez você precise de uma instância Redis, você precisa de uma instância
SQL postgres. E
aplicativos populares e muito populares foram conteinerizados e
disponibilizados como imagens de
contêiner
para você instanciar imagens. Os custos são contêineres
em sua própria máquina. Agora, trazendo-o de volta
ao Docker Desktop, se você
entrar no hub, saiba que
criou um Arkon. Então, a partir daqui, você
realmente terá acesso ao seu próprio
repositório, conforme necessário. Então, aqui é onde
eu empacotaria meu contêiner e o
publicaria no hub, tudo
usando o Docker Desktop
como ferramenta. Tudo bem, eu não vejo mais uma vez, eu posso ver todas
as imagens locais que eu teria tirado. E uma vez que eu crio um contêiner, eu tenho acesso a ele depois. Então você pode ver aqui que eu tenho
um contêiner RabbitMQ, eu tenho um contêiner Mongo DB de dois contêineres para
Microsoft SQL Server e eu tenho um para esboço 3D. Então, quando
voltarmos,
analisaremos todo o fim de semana global. É trazer uma imagem e
criar nosso próprio contêiner.
4. Criar um recipiente: Agora, do jeito que está, o Microsoft
SQL Server é quase exclusivamente utilizável apenas
em máquinas Windows. Agora, se você estiver usando
Mac ou Linux, não se preocupe,
ainda há uma solução para você. A solução número um
seria usar
uma máquina virtual para poder usar o VMware ou alguma outra ferramenta que
ofereça suporte à virtualização. E você pode criar
uma máquina
virtual sistema operacional Windows
e depois usá-la. Saiba que isso pode consumir muitos
recursos. E eu não vou fazer você
passar por tudo isso só
para usar o software. A alternativa para um ambiente
virtualizado para Windows seria usar o doc. Eu encorajaria você a
lançar seu terminal. Então, mais uma vez, estou usando
uma máquina Windows, mas seu terminal no Linux ou Mac OSX seria
muito parecido com este. E você pode simplesmente executar o comando docker apenas para
garantir que ele esteja instalado. E se você ver algo
parecido com isso, eles não sabiam que
você tem acesso aos comandos
da CLI do Docker. Tudo bem, então o que queremos
fazer neste momento é executar um comando chamado
Docker Pull, que amplie um pouco para
facilitar a leitura. Então, vamos fazer
docker, pull, docker, pull. Então vamos extrair
isso que chamaremos de imagem. Portanto, o Docker tem arquivos
predefinidos que revestem o ambiente necessário para um aplicativo
específico. E essas são chamadas de imagens. A imagem que queremos é a imagem do Microsoft MS
SQL Server. Então, vamos fazer um docker, puxar contra essa imagem
para que você possa clicar em pausa, certifique-se de digitá-la do
jeito que eu fiz. E quando você pressiona Enter, ele vai
dizer: Ok, eu estou recebendo litros e então você
vai ver o download. Então eu já tirei essa imagem, então eu já
a tenho na minha máquina. Mas você vai
ver que está puxando. E então ele vai
começar a mostrar suas métricas do carregamento concluído. E eles realmente se
pareceriam mais ou menos assim. Portanto, esta é uma captura de tela que
tirei anteriormente, quando estava baixando. E você vai
ver que isso vai
gerar um monte de lentes
parecidas com essa. E você vai ter
essas tags de download. Depois de concluído, a próxima etapa é
realmente executá-lo. Para executá-lo, você
precisa desse comando. Então, vamos dizer Docker
run e depois hífen
e, em seguida, faremos
a aceitação do eula. Então, o que acontece é que o SQL
Server geralmente tem um
desses documentos que você precisa para aceitar os
termos e condições. Então, estamos apenas colocando
em um parâmetro que sim, aceitamos os termos
e condições. E depois outro
que diz uma senha. Então, se você analisou o processo de instalação
quando estamos usando o Windows, podemos usar
a
autenticação do Windows para nos conectar ao
banco de dados, certo? Portanto, tudo o que precisamos é de um nome de máquina e podemos usar um usuário do Windows, o usuário atual do
Windows, a autenticação
e a desconexão do Windows. Agora, como isso é mais escuro
e é um contêiner, não
há janelas ou portas ou Mark ou não há autenticação
Linux. Portanto, não é verdade que
você possa simplesmente se conectar usando o usuário padrão
em seu computador. Portanto, esta etapa é
aplicável se você estiver usando Windows,
mac, Linux etc. Então, o que precisamos fazer é
especificar uma senha SA. Portanto, o ESI é o usuário padrão, o que significa administrador
assistente de administração do sistema. Toda vez que você instala
um mecanismo de banco de dados para o Microsoft SQL Server, você obtém esse usuário de ensaio. Então, vamos
configurar essa SA, senha e você pode inserir
qualquer senha que desejar. Estou apenas inserindo uma senha
forte aqui. E isso é realmente possível
que você veja em outras demonstrações que você pode assistir em qualquer lugar na Internet. Portanto, essa senha não é necessariamente exclusiva para
mim ou para este exercício. Você pode inserir qualquer valor de
senha com o qual se sinta confortável
e se lembre. Então, estou apenas dividindo a palavra senha
forte, é claro, com
caracteres especiais, números e algumas letras maiúsculas. Em seguida, especificamos a porta. O porto aqui
na frente é importante pelo qual
queremos passar. O porto. Na outra extremidade do cólon
está a porta para a qual ele será mapeado. Então, o que isso significa é que o SQL Server por padrão, transmite
a partir da porta 1433, que é a porta padrão. Portanto, sem fazer nada, especificar qualquer porta
ou qualquer coisa
sempre passará por 1433
desejos de conexão. No entanto, o Docker está sendo executado em seus próprios
ambientes especializados, então precisamos limpar. Essa é a porta padrão
e, em seguida, essa é a
porta da máquina de guerra que desejará
atravessar um túnel para chegar a esse esporte. Então, você pode simplesmente
deixar isso como 14334233. Se você ainda não quer ter o
SQL Server instalado e está
executando Mac e Linux, então 143 é, 33 está bem. Você não precisa
fazer nada extra. Você pode simplesmente se conectar. No entanto, como estou
usando uma máquina Windows, tive que mudar minha porta porque a
1433 já está ocupada pela minha instalação nativa
do SQL Server. Então, estou apenas mostrando que
você pode fazer 14331433 por padrão. Ou você pode colocar sua própria porta específica,
se desejar. Depois, o próximo. A última coisa é que vemos hífen D e depois
especificamos a imagem
que queremos executar. Então, basicamente, estamos dizendo que o
docker executa essa imagem e garantindo que todos esses parâmetros
intermediários estejam configurados. Isso é essencialmente
o que acabamos de fazer. Então, quando você pressiona Enter e
faz o upload desta para execução, o que ele fará é iniciar imagem dentro
da interface de usuário mais escura. E na interface do usuário você verá
que, você sabe, tem embaixo da
banheira do contêiner um contêiner. E você poderia ter dado um nome
ao contêiner. Não especificamos um
nome no comando, mas você poderia ter colocado traço n e dado a ele
um nome específico. Então, quando você
deixar de fornecer um nome, você receberá um nome aleatório, como o que você vê aqui
com esses nomes, pelo
menos Docker you, eu indicarei o tipo
de imagem que estamos usando. E você verá aqui as especificações da porta de
acordo com o que configuramos. Então, como eu disse, você pode portas
alternativas e isso
seria bom se você tivesse vários contêineres
da mesma tecnologia que bloqueariam a execução da porta
específica do UP. Mas se você não
tem a tecnologia instalada como no meu MongoDB, eu não tenho o MongoDB
rodando na minha máquina, então não vou usar
uma porta alternativa. Vou apenas dizer que
use a porta padrão, mapeie-a para a porta padrão e aja como o software real. Para SQL Server. Eu tenho várias
instâncias em execução e quero essa instância
de uma porta
específica que eu possa
acessá-la diretamente quando precisar me conectar. Agora, vamos dar uma olhada na conexão. Então, para me conectar, posso usar qualquer uma das minhas ferramentas de gerenciamento do SQL Server. Já analisamos
algumas dessas ferramentas. Só para me encontrar nesta
semana, vou usar o Data Studio e me conectar. Vou seguir em frente e
criar uma nova conexão. E para o servidor, vou
escrever o nó do host local. O Darker será
exibido em anfitriões locais. E é por isso que esse
número de porta é importante. Porque normalmente
o comando localhost 1433
seria a forma de se conectar
à instância do
SQL Server instalada localmente. Se, especialmente se você estiver
administrando um nível profissional,
corporativo ou de
desenvolvedor, certo? Portanto, o host local com a
porta me conectaria à
instância padrão instalada em minha máquina. No entanto, como eu quero
a instância mais escura, preciso acessar o host local e a porta específica
que forneci durante a configuração
do contêiner. Para autenticação, não posso usar autenticação
do Windows
que estabelecemos. Eu tenho que usar a
autenticação SQL. E eu vou dizer redação
e depois a senha. Eu esqueci. Então, aqui está uma
maneira rápida de se esquecer esses valores do ambiente, você pode recuperá-los
da interface do usuário do Dr.. Basta clicar
no contêiner em execução e usar dicas visuais
para saber quando ele está sendo executado. Aqui está em execução e você verá os registros acontecendo em
segundo plano. Você pode ir para Inspecionar, você pode ir para o terminal, etc. Se eu for para Inspecionar, eu vou ver todas as variáveis de
ambiente que foram configuradas. Então fizemos com que o eula aceitasse eula. Por quê? Essa é uma variável de
ambiente. Aqui está a senha SA. E olha isso. Eu tenho a senha via
disponível para mim aqui. Sempre que você faz essas
configurações e define variáveis de
ambiente
e sua mente esquece onde estão todos os humanos, você sempre pode simplesmente pular
até o contêiner em execução, inspecionar e ver as variáveis de
ambiente. Então, vou voltar
aqui e digitar a senha. E então eu vou
clicar em Conectar. Agora estou recebendo o erro de
que foi bem-sucedido, mas precisa de uma conexão
confiável. Ok, então eu estava apenas mostrando o certificado do servidor
e lá estou eu. Agora estou conectado à instância
do SQL Server em
execução no meu contêiner. E esse é um contêiner que é realmente usado em outro curso, desenvolvimento multiplataforma do
asp.net Core,
que, obviamente, é onde
eu realmente ensino em espera. Você pode usar o asp.net
Core para desenvolver uma solução em qualquer ambiente. Então, vamos fazer um pouco mais sombrio, Isaiah Sean nesse curso. E eu só estou te mostrando isso. Estou apenas compartilhando isso com
você para que você saiba que é por isso
que esse banco de dados existe. Então, obviamente, você
não teria bancos de dados se tivesse
criado esse contêiner. Esse contêiner funciona como qualquer
outra instância do SQL Server. E enquanto o
contêiner estiver em execução, você
poderá interagir
com ele da mesma forma. Você pode se conectar a ele, criar aplicativos para usá-lo. E adivinha se eu parar com isso? Então eu posso parar esse contêiner neste
momento, certo? Se eu tentei fazer
qualquer outra coisa aqui, como tentar
entrar no banco de dados, observe que meu Data
Studio vai
se deparar porque
perdeu a conectividade com o
banco de dados, com o servidor. Então, desde que esse
contêiner esteja funcionando. É por isso que dissemos que,
ao instalar um software, talvez
você não
queira necessariamente que ele seja difundido e executado o tempo
todo. Você quer parar, parar
e iniciar sob demanda. É aí que a conteinerização
pode desempenhar um papel importante em ajudar você a ser o mais eficiente
possível com os recursos do sistema durante o
desenvolvimento. Agora, saiba que temos alguma
experiência em extrair uma imagem, configurar nosso contêiner. E essas etapas
estão bem documentadas, então não estou inventando essas coisas. Você pode encontrar tudo isso. Depois de encontrar a imagem interesse no Docker Hub, você pode clicar nela e ver todas as
formas recomendadas de as
formas recomendadas configurá-la em todas as variáveis de
ambiente necessárias para a
configuração. Mas agora que
vimos como podemos usar uma imagem de terceiros,
avise-nos, configure nosso próprio aplicativo dotnet
Core, veja um fim de semana inteiro, conecte-se a essa
imagem e veja como podemos colocar um aplicativo
em contêineres.
5. Configuração . Projeto NET Core: Agora vamos criar nosso próprio projeto
asp.net Core. E, no futuro,
vamos colocá-lo em contêineres. Então, é claro que estamos usando
nossa solução regular. Vou adicionar um novo projeto. E desta vez
vou usar um projeto de API. E eu só estou escolhendo uma API acordo com o tema de que contêineres e
conteinerização funcionam
bem com o design
arquitetônico de microsserviços. Então, vou pular até aqui criar nosso novo projeto de API. Vou apenas
chamar isso de microserviço. Uma API adota
contêineres que demonstram. Assim, você pode reutilizar o nome. Claro, você não precisa. E então eu vou clicar em Avançar. Agora, nesta etapa, podemos escolher nosso tipo de
estrutura de
autenticação e podemos
optar por ativar o Darker. Portanto, não vou habilitar o
Darker aqui, vamos
adicioná-lo manualmente ou usar um método
diferente para adicioná-lo. Mas para o segundo microsserviço, você verá a
diferença quando fizermos
isso , porque
queremos mantê-lo simples. Vou fazer uma
API mínima e podemos clicar em Criar. Agora, é claro, se você estiver usando o
Visual Studio Code
e a CLI dotnet, abra seu terminal
e digite o comando dotnet new web hyphen 0 para a saída e dê o nome ao projeto. E então, uma vez feito isso, você pode inserir um CD na pasta
recém-criada e executar o código sem parar para iniciar o Visual Studio Code
nessa pasta. Agora temos nosso projeto
padrão de API da Web e somos todos desenvolvedores,
então sabemos o que fazer. Conheça esse
lindo código de tumor raro e nos conectamos ao nosso banco de dados
e a todos esses ativos. No entanto,
mais uma vez, quando precisamos mudar
de nossa máquina para o ambiente de desenvolvimento
e implantamos, pode
haver diferenças
entre os ambientes que a fazem funcionar em sua máquina e, em seguida, ela não funciona em definição. E então acabamos
com desculpas como se funcionasse ontem ou dizemos, bem, funcionou na
minha máquina, pois ele
vai usar sua
máquina na produção. Todos nós sabemos disso. É por isso que a
conteinerização torna nosso aplicativo
muito mais portátil e muito mais estável, independentemente
de onde ele seja implantado. Agora, vou adicionar suportes de contêineres a
esses aplicativos. Eu criei o aplicativo
e, falando sério, nós anulamos o belo
código e tudo mais. Mas sabemos que precisamos
dele em um contêiner, então estou disposto a clicar com o botão direito do
mouse no projeto. E então eu vou
até Adicionar. E então você verá
aqui os suportes do docker. Então, quando eu clico no
suporte do Docker, vou me perguntar ,
ok, qual é o alvo ou se eu queria
deixá-lo como Linux? Bem, obviamente, você pode alternar entre eles e você
quer ter certeza escolher o
ambiente apropriado com base nas quase
dependências das opções de biblioteca, porque nem tudo
funciona no Linux. Mas, por enquanto, para
este aplicativo simples e dotnet, o Core é multiplataforma. Eu vou usar o Linux. Eu clico em OK, então obtemos esse novo arquivo
chamado arquivo Docker. Portanto, esse arquivo Docker não
estava lá inicialmente. Mas vamos avaliar o que
esse arquivo Docker está fazendo. E parece confuso, mas ao lê-lo,
você verá que tudo bem, é algo que
pode ser entendido. A primeira coisa que ele faz
é extrair uma imagem base. Então, de e depois está
dizendo o nome da imagem. Então, lembre-se de que quando fizemos nosso
docker pull para o SQL Server, precisamos especificar
um caminho semelhante a este, onde dissemos
SQL Server, em vez disso, não
especificamos nossa tag. Então, se você quiser uma
versão específica de uma imagem, significa que esta é a
imagem, mas depois dois pontos. Então, o valor após
os dois pontos significa a tag ou a versão específica na
qual você está interessado. Então, estamos fazendo um aplicativo
asp.net. Então, obviamente,
gostaríamos que a imagem fosse dotnet seven asp.net. E então estamos vendo como base. Em seguida, ele especificará, ok, depois de
criar esse contêiner,
criaremos nosso
diretório de trabalho chamado portas
expostas 84 para três. E então, a partir dessa imagem do SDK
em que queremos criar. Então, mais uma vez, especifique o diretório de trabalho como SRC e copie os arquivos do diretório
CSP, certo? Então você vê aqui, esses
são apenas os caminhos. Portanto, copie
praticamente esse
arquivo CS broach desse caminho e, em seguida, execute um comando
dotnet restore. Então, aqui você começa a
ver que apenas usar os mesmos comandos da
CLI dotnet que
usamos é apenas fazer isso
em nosso nome, certo? Então, ele está fazendo uma restauração nesse arquivo CSV e
copiará tudo nesse arquivo. Em seguida, está configurando
esse diretório
de trabalho para estar lá novamente. Então, se eu passar
linha por linha, certeza, faz sentido, certo? Essencialmente,
vamos executar novamente dotnet build como lançamento. E a saída será. Construção Slash. Esses são diretórios
que não precisamos
criar e não estão sendo
criados em nossa máquina. Em vez disso, eles serão
criados
no contêiner que está fazendo
essa compilação do compilador. E então, a
partir desta etapa, logo que essa etapa for concluída, pegue o que quer que seja
chamada de publicada. E eles iriam
executar o comando de publicação, que faria o
mesmo tipo de lançamento. Pegue o que está nessa pasta
publicada. E vai dar uma pequena flor aqui para dizer que
usar cavalo é igual a falso. Tudo bem, mais uma vez, isso
é gerado para nós. Não precisamos necessariamente
oferecer esse arquivo. Nós podemos. É bom entendê-lo, modificá-lo, mas, de um
modo geral, você não precisa. E depois de tudo isso, da base, veremos que
o diretório de trabalho está ativo e copiará tudo da publicação
desse diretório. E então o ponto
de entrada será essa DLL. Portanto, os aplicativos dotnet Core geralmente são
executados com base nessa DLL. E é isso que inicia o aplicativo
em execução no contêiner. Agora, como eu sei que isso vai
ser executado em um contêiner? Então, deixe-me passar para o projeto de startup
do microsserviço que
acabamos de criar. E você verá que o botão em
estrela é mais
escuro e mais escuro com todos os outros. Como se eu fosse até o
blazer em HTTPS. E já
analisamos
as configurações do gramado e sabemos que o perfil de lançamento
tem HTTP, HTTPS. Mas se você olhar para isso, verá que agora há
uma entrada mais escura aqui. E a entrada mais escura terá aquele URL de lançamento
com a arrogância. Então, tudo é
configurado para você depois de adicionar
o arquivo Docker. Mas, basicamente,
vai continuar e ficar mais escuro, certo? Então, quando eu for até esse novo projeto de inicialização
e ver run with darker, meu aplicativo será iniciado
exatamente como eu esperava, certo, então ele será
lançado em um navegador. E eu poderei ir em frente
e usá-lo como eu espero. Que evidência eu tenho de
que ele está sendo executado em um contêiner e não apenas
pelo Visual Studio. Bem, se você olhar para a janela do
Visual Studio, o novo painel
teria aparecido. Então você provavelmente
nunca viu isso antes. Contêineres. E neste painel você vê que esse contêiner ou o
aplicativo
hospedado está sendo executado está aqui como um contêiner que
está sendo executado, certo? Não, você também poderá
examinar todas as variáveis de
ambiente. Então você verá o desenvolvimento da
versão, todas aquelas
variáveis de ambiente que não sentamos , mas estão todas lá. Também temos portos. Então você olha para a porta aqui, você verá que ela está
criando portas. Lembre-se de que tivemos que
criar portas para o túnel. Então, 21433 quando estávamos fazendo
nossa imagem do SQL Server. Então você verá aqui que
temos uma porta que está mapeando para a porta 80 e
mapeando portas para a porta 443. De qualquer um, eu posso
clicar e sutiãs. Então, quando olharmos o
endereço na interface do usuário do Swagger, veremos que
estamos no 769, que está mapeando para a porta 443. Você também notará
que, se tiver interface de usuário
mais escura aberta e em execução, uma interface de usuário
mais escura aberta e em execução, terá um novo contêiner com o nome do
aplicativo também em execução. E está te mostrando o porto. E você pode clicar
para mostrar todas as portas. Portanto, todas essas são
pistas visuais e evidências que não temos um aplicativo em
contêineres. E isso é um microsserviço. E, mais uma vez, não se
limita aos microsserviços, mas é recomendado com microsserviços
porque permite que cada microsserviço viva em seu próprio ambiente, independente de todos os outros serviços com suas próprias dependências e tudo o que ele precisa
para ser executado de forma eficaz. E, mais uma vez, é portátil. Se você estiver usando o Visual
Studio Code e quiser colocar em contêiner o
aplicativo
que você tem aqui, o que você precisa fazer é pegar as extensões
para mais escuras. Portanto, se você simplesmente acessar Extensões e pesquisar o
docker, instale-o. Eu estava tentando
rolar e encontrá-lo, mas você pode simplesmente pesquisar
por Darker
e instalar a extensão
Docker. Certifique-se de que você está
comprando o Microsoft One. E então, uma vez que
você tenha isso, você obterá esta guia que
permite ver todos os contêineres
e oferece um poço semelhante, não
quero dizer semelhante, mas fornece informações
suficientes comparação com o que você
teria experimentado no Visual Studio sobre
os contêineres em execução, bem
como
imagens diferentes que você tem disponíveis se tivesse
retirado em várias imagens, nos
permite colocar
esse aplicativo em contêiner. Isso é o que provisionamos
em nosso código do Visual Studio. No Visual Studio Code, mantenha pressionadas as teclas Control Shift
e P, e você verá o traidor
mostrar todos os comandos. Então, controle Shift
N P e isso
iniciará nossa Paleta de Comandos. E então você verá aqui que E tem a opção de
adicionar um arquivo Docker. Se você não encontrar essa opção,
basta começar a digitar Docker e ela
aparecerá de qualquer maneira. Então, lembre-se dessa adição. suporte do Docker consiste, na verdade,
apenas na adição de um arquivo Docker. Então, se selecionarmos
isso, eu posso especificar o tipo de aplicativo
que eu quero oferecer suporte. Portanto, é um aplicativo asp.net
Core. E então podemos
especificar o sistema operacional
novamente e especificar as portas. Vou deixar aquele porto. Tudo bem para mim. Posso escolher se quero
um arquivo de composição do docker, veremos o
docker-compose mais tarde, alguém para dizer não por enquanto. E então ele vai
gerar esse arquivo Docker para mim
usando uma sintaxe gerar esse arquivo Docker para mim muito semelhante à que vimos agora
no Visual Studio. Agora, para executar essa API em Darker
a partir do Visual Studio Code, podemos ir para a guia de depuração
e, em seguida,
escolher na lista suspensa, o darker dotnet lunch. E então vá em frente
e execute-o novamente, veja alguma atividade acontecendo
aqui no terminal. E se você olhar de perto, verá que os pulmões
são muito parecidos com os que você poderia ter visto no Visual Studio quando
ele estava em execução, mas ele está executando alguns
comandos do Docker em segundo plano. E depois de algum
tempo, não
vamos fazer
nosso escurecer funcionar. E vemos Hello World. Era um endpoint de API simples que apenas
retornaria HelloWorld. Se olharmos em nossa interface de usuário mais escura, você também verá o novo contêiner funcionando com o nome. Tudo bem, então aqui
temos a porta 32771 funcionando
novamente, esportiva 5099. Então, poderíamos ter
especificado que
queríamos 84 por três para isso. Eu poderia ter dito 80 vírgula 443 quando
me perguntou sobre as portas. Eu não fiz isso, mas estou apenas
informando que essa era uma opção que teria fornecido um mapeamento
semelhante ao que temos aqui. Agora você sabe como
colocar
seu
aplicativo dotnet Core em contêineres usando o visual Studio e o
Visual Studio Code. Obviamente, ainda estamos
rodando em depuração. Então, eu vou
parar a depuração. E isso nos
permite realmente depurar nossos aplicativos enquanto eles estão
em um contêiner. Agora, se seguirmos
as etapas novamente para adicionar um novo, deixe-me adicionar um novo projeto. Desculpe. Quando adicionamos o projeto, tivemos a opção de
adicionar um suporte mais escuro. Então, vou clicar
em um aleatório aqui. E tivemos a opção de
habilitar o Docker. Então, tudo isso teria sido nos permitir
escolher o sistema operacional aqui
e, em seguida, ele
teria gerado ou projetado com o
arquivo Docker já provisionado. Você pode fazer isso desde
o início se souber que vai
usá-lo mais escuro ou
pode ser facilmente adicionado posteriormente quando suas ambições
chegarem a esse ponto. Não, está feito. São sete. Existem comandos dotnet
que podemos usar para realmente publicar nosso aplicativo em um contêiner sem a
necessidade de um arquivo Docker. Um arquivo Docker pode ser
usado para qualquer versão do dotnet e é universal. Você não precisa se preocupar se
estiver usando um arquivo Docker. Mas quando voltarmos,
veremos como podemos usar comandos dotnet nativos
para conteinerizar ou aumentar.
6. Containerize . App NET: Agora, nesta lição,
veremos como
podemos colocar um dotnet
em contêineres usando o dotnet publish ou os comandos
nativos da CLI dotnet. Agora, isso é único, pelo
menos no momento
da gravação, para dominar sete,
e tenho certeza de que estará disponível
em versões posteriores. Até agora, dotnet six e abaixo, você ainda precisa do arquivo Docker. No entanto, se estivermos avançando com seus sete,
podemos fazer isso. Eu vou seguir em frente
e criar um novo projeto. E eu vou usar o
Visual Studio para esta demonstração, mas você pode ficar à
vontade para continuar
usando o Visual Studio Code. A maior parte será conduzida pela linha de comando. Mas vou criar
outras APIs de microsserviço. Vou chamar
esse microsserviço
para contêineres de pontos de API que demonstram. E vamos seguir em frente
e criar isso. Não estou adicionando suporte ao Docker. Não estou mudando
nada na configuração anterior. E agora temos nosso novo projeto. Então, nesse novo projeto, precisamos adicionar um
novo pacote, certo? Então, vamos usar
o comando dotnet CLI. Estou usando o dotnet CLI
porque todos podem usá-lo, esteja você
no código do Visual Studio ou do Visual Studio. Então, acabarei de lançar o
terminal aqui no Visual Studio. E eu vou executar
o comando dotnet add package e vamos adicionar microsoft.net dot
build dot containers. Então vá em frente e
instale esse pacote. Agora, com esse pacote instalado, podemos verificar clicando
no arquivo
do projeto CS e
você o verá aqui. Agora, quando queremos dar um nome ao
nosso contêiner, às vezes
podemos ter nomes
inválidos como projetos. Então, se você quiser
mudar o nome, você poderia realmente
adicionar um nó aqui
na seção Grupo de propriedades do CSB Raj. E isso seria
um contêiner e acertaria minha imagem ortográfica, Nim. E então, com esse nó, você pode realmente dar outro nome a
ele. Então, vou chamá-lo
de macro microserviço. Corra para escrever apenas alguma coisa. É microsserviço ponto a ponto api dot Clinton
é aquela demonstração. Quero
descontinuá-lo para ser chamado apenas microservice dash to write, apenas para mostrar
que podemos renomear a imagem real antes de
ser publicada. Agora, quando eu estiver pronto para publicar usando as redes de pontos, as
amarelas novamente, posso dizer dotnet publish e vou especificar
o sistema operacional. Então, dash, dash OS, e eu vou
ficar com Linux e dash, dash arc. E estamos especificando 64 para
mostrar que queremos 64 bits. Em seguida, dizemos barra para publicar contêiner e, em seguida,
barra C release. Então, com tudo isso,
o que estamos fazendo aqui é ver que queremos
a configuração de lançamento, que é o traço C. Mais uma vez, a arte do traço está especificando
uma arquitetura de 64 bits. E estamos especificando que
queremos um sistema operacional baseado em Linux. Saiba que quando esse comando for executado, você verá que eu
imprimi alguns registros, mas vá em frente, execute-o. Clique em pausa. Quando estiver pronto,
podemos ajudar juntos. Mas o mais importante é que você
verá isso para criar a imagem com
o nome do contêiner
especificado. Se não especificássemos o nó do nome do
contêiner
, você teria obtido
uma imagem semelhante
ao nome do projeto que
vimos antes. Então, essas são apenas pequenas pepitas que você pode ter em mente. O fato é que sempre que
precisamos configurar essa
imagem semelhante à inteira, temos o arquivo Docker
configurando todo tipo de ambiente, ou seja,
false, e assim por diante. Para o contêiner, podemos realmente especificar um nó
diferente aqui. Então, se eu quisesse, digamos que estamos usando o
dotnet 6.7 are, eu só queria um
dotnet six Runtime. Nessa imagem, eu poderia realmente
vir aqui e especificar imagem do
contêiner e,
em seguida, colocar o nome da imagem. Então, vamos ver se eu queria
o tempo de execução do dotnet six. Eu pude ver MCR, microsoft.com.net reduzirem o tempo de execução
e, em seguida, a tag para 6.0. Tudo bem, se eu quisesse outra
coisa, como se eu quisesse realmente marcar essa imagem sozinho,
eu poderia especificar. E eu vou apenas
remover este. Foi um exemplo, mas eu poderia especificar a tag da imagem do contêiner. E então isso
me permitiria definir minha própria versão dessa caça
ou imagem em particular que estou promovendo. Digamos que depois de uma correção de bug, a imagem original fosse 1.2, 0.0. Mas talvez eu tenha corrigido um bug. Eu sei que quero que isso
seja 1,2, 0,1. E então, se eu executar novamente o
comando,
veremos que obteremos uma
imagem totalmente nova com essa versão da tag. Lá vamos nós. Então, acabei de executar o comando novamente. Eu sei que tenho a nova imagem
com a tag 1.0, 0.1. Agora, lembre-se de salvar o arquivo CS Bridge e
é por isso que eu tenho tantas execuções. Aconteceu comigo na
primeira vez que eu não vi. Sempre que você faz uma alteração
aqui, você precisa ver porque isso não é uma operação de construção, é uma operação não publicada. Então, se você não economizar, ele não verá que a mudança é poder seguir em frente e avançar. Há várias
outras coisas que você pode realmente adicionar ao configurar a
imagem do seu aplicativo a partir desse ponto. Então, se você quiser
ter várias tags, você pode realmente ver as tags de imagem de um
contêiner. Observe que o S é
diferente do botão. E você pode especificar nomes de versões
diferentes usando técnicas de
controle de versão alfanumérico e semântico. E você só vai querer
usar um ponto e vírgula para separar cada tag de versão. Você também pode adicionar um grupo de itens qual você pode adicionar mais metadados. Assim, você pode configurar as portas de
contêiner que
deseja que esse contêiner tenha
depois que a imagem for criada. Você também pode criar uma variável de
ambiente de contêiner. E isso, já
vimos isso antes, especialmente quando estamos configurando nosso contêiner do SQL Server onde tivemos que aceitar
o contrato de licença. Então, vamos em frente e
criamos essa variável. Então, toda vez que o
contêiner gira isso, esse valor variável
está disponível. Aqui, onde está, no
registrador, a verbosidade que eu traço. Isso significa que esse contêiner
deve divulgar o máximo de informações geradas pelo nosso dotnet
Core up, tudo bem, e sabemos que os
núcleos podem ser um pouco falantes, então ele deveria estar
transmitindo tudo
isso para o console do contêiner. Outro exemplo de uma variável de
ambiente que você pode querer definir seria uma para o ambiente ASP NET Core. Então, aqui, quando o
executarmos localmente, ele sairá com o desenvolvimento como uma variável de
ambiente. No entanto, quando fazemos uma publicação e lançamos a
configuração, essa variável será
a produção. Na verdade, poderíamos substituir essa configuração
padrão e ver quando
você está nesse contêiner, eu quero que essa
variável de ambiente seja desenvolvimento ou QE,
teste de barra ou produção, etc. Então é assim que você pode pensar no uso de variáveis de
ambiente. Você também pode adicionar rótulos
e rótulos que ajudam apenas com os metadados e a listagem
quando eles estão no registro. Também podemos especificar
o registro aqui, mas ainda não estamos
prontos para isso. Então, com tudo isso feito, posso fazer outro push e criar essa imagem
ou atualizá-la. Então, mais uma vez, são
imagens, não contêineres. Agora eu quero
realmente executar minha imagem agora para ter certeza de que
a imagem existe. Eu posso pular
para a interface mais escura, ir até as imagens. E então você verá
aqui que todas as versões
das imagens que você publicaria
deveriam estar aqui. Então você vê aqui que é
1,0 ponto, 0,1, 0,0, 0,1. E se eu selecionar qualquer um deles, você verá esta
seção chamada camadas, onde são todas linhas, as diferentes etapas que
devem ser seguidas para finalmente criar o contêiner
para esse aplicativo. Se eu acessar imagens, você verá que ela está usando a imagem DBN porque
eu disse que queria Linux e está usando minha
imagem que eu criei. Então, para executar isso, poderíamos realmente clicar
na imagem e depois clicar em executar. Na verdade, eu não gosto
de fazer isso, certo? Na verdade, prefiro
usar a linha de comando. Agora, ao lado dela, você
verá puxar e empurrar o cubo. Então, essa é a nossa imagem local,
então não há nada para extrair. Mas se fizermos uma pesquisa, isso significa que você obterá a
versão atualizada dessa imagem, especialmente se ela
for a mais recente. Então, como você viu, conseguimos atualizar
a imagem com a mesma tag. Portanto, se houver atualizações
nessa versão, sempre
podemos puxar e
ela fará uma atualização. Também podemos enviar o hub, que significa que é aqui que
vamos enviar do nosso repositório local
para o Docker Hub. Eu já teria mostrado
, uau, que pelo menos
quando o IVR continua
pressionando o hub, você pode ver seu próprio
contêiner no hub e puxá-lo de volta para baixo em qualquer outra máquina, conforme
necessário, e começar a trabalhar. Então, é fácil
memorizar seu contêiner
depois de criar. Vamos seguir em frente e operar
esse novo contêiner. Então, o que vou fazer é abrir uma janela de terminal e
aumentar essa. Então, peço desculpas se usar
aquele no Visual Studio
machucar seus olhos. O que eu espero saber. Então, estou usando uma janela de terminal. Eu já fui
até o diretório onde fica a demonstração da
nossa API de
ferramentas de microsserviço. E o que vou fazer aqui é executar um comando que
diz docker run. Então, já vimos esse comando docker
run antes, certo? Vou especificar o traço, TI, especificar uma porta. Então, eu vou dizer isso
que eu quero que ele funcione. Na porta 80. 80 e isso deve ir até a porta
84, tráfego amarelo. Não quero complicar
nada e usar 443. E depois vou especificar
o nome da imagem. Então, ferramenta de hífen de microsserviço, e eu posso especificar o
destino, se eu quiser ou não. Então, deixe-me seguir
em frente e apertar Enter. Vamos ver o que acontece. Então você não consegue encontrar
imagens com as últimas. Portanto, é muito importante
que você defina a tag mais recente no
que
deve ser extraído por padrão. Então, deixe-me especificar essa tag, que é 1,0, 0,1, e tente novamente. E desta vez,
na verdade, ele exibirá alguns registros que
se parecem registros do aplicativo
asp.net Core. Então, o que acontece se eu
tentar acessar o aplicativo? Então, dissemos que o
aplicativo deveria estar ativo na porta 80, 80. Então, quando eu abro
um navegador e vou para a porta 80, 80 do host
local. E então eu coloquei as previsões do
tempo, que é o ponto final
que reside nessa API. Vemos que estamos
recuperando nossa API. E veremos
também que temos uma pequena mensagem sobre o redirecionamento de HTTPS,
tudo bem por enquanto. Se olharmos na interface mais escura, veremos que também temos um novo
contêiner em execução. E este é, eu não
sei qual
é esse nome, mas mais uma vez, poderíamos ter
especificado o nome na execução
do Docker, se quiséssemos. Se eu clicar nele, você verá que ele também está
cuspindo troncos por aqui. Assim, você pode assistir aos
registros do console, você pode assistir aos
registros daqui. E, na verdade, a
razão pela qual está
saindo para o console
que o iniciou. Deixe-me parar com isso e
refazer o comando run. A razão pela qual ele assumiu
o controle do console é porque
não especificamos o dash d, o que significa que queremos que
ele seja executado como um daemon em
execução em
segundo plano aqui. É, isso libera o console. Tudo bem, então esse é outro
pequeno truque que você pode usar para liberar o console quando quiser executar
seu contêiner Docker, mas não quer que ele
assuma o controle do console. Então, aqui o contêiner do Docker
está sendo executado novamente. Eu só tinha que
sair e voltar para dentro. E você verá que está
funcionando novamente. E podemos ver o console
daqui sem assumir
o controle do console local. Agora você vê como
pode conteinerizar seu
aplicativo dotnet Core usando seus comandos da CLI dotnet
e determinadas configurações. Leia a documentação
que você pode usar e coloque diferentes configurações
que ressoam em você. Mas vou deixar isso para você. Agora, quando
voltarmos, veremos como podemos usar o docker-compose para
lidar com a orquestração de vários aplicativos que
estão em contêineres.
7. Orquestração com composição de Docker: Portanto, já temos uma ideia do que é orquestração de contêineres. orquestração de contêineres
basicamente significa que temos vários contêineres e
precisamos ser
capazes de orquestrar o início do feriado. Por que eles começam? Se, se um depende do outro, qual deles começa primeiro, etc. Então, há várias coisas
que precisamos configurar
para nossos contêineres antes que
a palavra realmente comece. Então, se eu tiver, digamos, um
aplicativo de microsserviços, e todos esses microsserviços existirem em seus próprios contêineres. Mas para que o aplicativo seja executado, todos esses aplicativos precisam estar e
funcionando simultaneamente. Então, gostaríamos de ter
certeza de que temos uma maneira muito repetível de com que todos eles sejam
executados ao mesmo tempo. Então é aí que entra o Docker
Compose. Então, vou
adicionar suportes
mais escuros à
nossa segunda API. E apenas
clicando com o botão direito do mouse e fazendo, seguindo o assistente, é claro, você sabe, para fazer isso também no
visual Studio Code. Mas agora temos o arquivo
Docker existente em ambos os aplicativos. Agora, quando clico com o botão direito do mouse novamente, posso realmente adicionar suportes de
orquestração de contêineres. Então, quando eu clico nesse,
ele vai me perguntar, ok, qual orquestrador
eu quero usar? E, por padrão, terei o
Docker Compose lá. Então, vou
prosseguir e clicar em OK. Confirme que eu quero
usar o sistema operacional Linux. E isso vai gerar um novo projeto com
alguns novos arquivos. O primeiro arquivo aqui
é um ignorar mais escuro. Assim como nosso arquivo
gitignore, há certas
coisas que não precisamos necessariamente
trazer com o
contêiner e tudo mais. Então, é só dizer
ignorar tudo e compilar
todo o resto. Também temos as
configurações de gramado que o JSON, que nos fornece uma AUC do Docker Compose ,
lançou aqui. Agora está assumindo o controle.
Podemos simplesmente dizer docker-compose e executá-lo uma vez aqui no Visual Studio. Então, com isso, podemos simplesmente
criar o que o arquivo de
composição do Docker diz. Não ou Docker. O arquivo de
composição do Docker tem duas partes. Temos o hífen mais
escuro composto e
temos a substituição. Ou a substituição nos permite especificar determinadas configurações que
queremos em cada contêiner. Então, aqui, deixe-me ir primeiro
do arquivo principal. Aqui estou vendo que
vou, a versão foi definida. Não estou disposto a mudar isso. E então temos uma
seção de serviços. E então, em Serviços, temos nosso primeiro serviço,
que é o microsserviço, um que especificamos. Queremos adicionar orquestração
e suporte para. Então ele vai dizer, bem, quando eu construir esse contêiner, vou chamar
a imagem de qualquer nome
gerado, hífen desse nome. E então eu vou construir
usando bem o contexto, onde quer que o projeto esteja, e o arquivo Docker ou as
instruções de configuração sobre
como esse contêiner deve ser gerado existem no arquivo Docker
em nosso projeto. Portanto, para
quantos aplicativos você tiver você precisa iniciá-los de uma só vez
durante o desenvolvimento. Você pode adicionar orquestração
e suporte. Então, eu também posso adicionar
orquestração e suporte ao segundo
microsserviço e o terceiro
n ao n. Então,
se eu fizer isso de novo e
especificar as mesmas configurações, você
verá que agora tenho um segundo microsserviço
aqui nesse arquivo. Fácil e agradável. Então, se eu pular para
o
arquivo de composição do Docker e ele crescer, porque agora
temos temos dois serviços diferentes e
quantos serviços você tem, você pode ter substituído R-naught. Mas aqui o que estamos
fazendo é especificar que o ambiente deve
ser desenvolvimento. Sempre podemos mudar
isso com base em nossas necessidades. Então, enquanto estivermos no Visual
Studio, é claro, essa
variável de ambiente definitivamente
desejará estar em desenvolvimento. Podemos especificar que
queremos portas HTTPS e HTTP. Lá vamos nós. Em seguida, podemos especificar volumes. Portanto, um volume em laranja mais escuro, conteinerização ativada é
basicamente uma era de armazenamento, de persistência. Portanto, quando o contêiner
está em execução, não
queremos
perder os dados. Quando
iniciamos o contêiner, ele deve se lembrar do
último lugar em que estava. Portanto, isso é especialmente
importante para contêineres
de banco de dados e contêineres de
esboço prontos, etc. Então, quando
dizemos volumes aqui, estamos apenas dizendo
que queremos armazenar os segredos do usuário. Também queremos armazenar algumas outras
configurações, certo? Portanto, quaisquer que sejam essas
configurações, persista-as mesmo quando
um contêiner não estiver em execução. Agora que temos
uma visão geral rápida de como realmente é nossa conteinerização ou Docker
Compose, ou Docker Compose
e substituição de arquivos. Vamos
ver o que acontece quando executamos o Docker Compose. Então, eu vou clicar em Run. E em nosso navegador, temos nosso primeiro microsserviço em execução. Agora, o primeiro microsserviço foi criado com o suporte do Swagger. Vemos como podemos chegar
a esse ponto final. Mas se eu voltar
para o Visual Studio, você notará na seção
com os contêineres que eu tenho um contêiner de
microsserviço, então
já tenho um para ele. Portanto, está criando um
novo contêiner com base na composição do docker. E está criando um contêiner para o segundo microsserviço. E apenas clicando
desta vez, ele conseguiu lançar
esses dois serviços que
podem ou não depender um do outro. Se eu olhasse na interface mais escura, você verá que
uma nova
seção do Docker Compose está aparecendo. E esta seção do Docker
Compose tem os dois contêineres para
os microsserviços. Ele também tem
portas diferentes para cada uma. Assim, posso navegar facilmente
até qualquer um deles. E eu posso simplesmente parar
todos eles usando uma parada. Eu também poderia ter,
provavelmente deveria tê-lo interrompido do Visual
Studio também. Agora que entendemos como o Docker Compose e a
orquestração funcionam. E há outro
nível em que apresentaríamos o
Kubernetes 0s, que faz muito mais do que
apenas criar contêineres. Mas veremos isso
brevemente mais tarde. Na próxima lição,
passaremos para o
Microsoft Azure
e
criaremos nosso serviço de
Registro de Contêineres. E então veja como podemos enviar nossos contêineres para esse registro.
8. Registro de contêiner do Azure: Tudo bem, então vamos
voltar ao nosso portal e
vamos procurar o Registro de Contêineres. Então, isso é um contêiner de pesquisa. E queremos registros. E vamos criar
nosso próprio Registro de Contêineres. Então, como sempre,
vamos
preencher este formulário. Então, estou colocando-o no grupo de recursos
usual. Eu lhe dei um nome. E observe que ele tem regras de nomenclatura muito
rígidas. Portanto, hífens, eu não sou uma carga ou
caracteres especiais não são permitidos. Então, estou chamando o meu, é claro que
não é ACR. E escolhendo a melhor
localização para mim, estou usando a inclinação básica. Então, isso custará um
pouco de dinheiro. Portanto, esteja ciente disso. Então, vamos
revisar e criar. Feito isso, podemos
acessar nosso recurso. Agora, obtemos o painel
normal e ele nos mostra
quanto armazenamento temos quanto dele é usado. Temos até um
URL público para nosso registro. Portanto, lembre-se de que, embora seja um URL público,
registros privados, usando a Microsoft como sua, o gerenciamento de usuários
integrado e o que quer que você esteja usando em
sua organização, você pode adicionar sua própria segurança ao
seu registro privado
para garantir que os desenvolvedores possam extrair, enviar e corrigir
imagens de contêineres adequadamente. Também temos os repositórios aos
quais podemos conectar nossas ferramentas para poder
gerenciar, extrair e enviar. Então, se eu acessar as chaves de acesso, poderei fazer login
como usuário administrador. Então, aqui está um nome de registro que é o servidor de login e usa
as credenciais do usuário administrador. Agora que tenho acesso
ao nome de usuário e senha
no nível de administrador, posso iniciar meu terminal. E vou
executar um login do docker, seguido pelo nome do endereço do
nosso servidor de login, que é no meu
caso, é cavalo, ponto
ECR como seu CR? Então, vou prosseguir
e pressionar Enter. Em seguida, ele vai
me pedir o nome de usuário. Então, vou copiar
e colar essa parte. E depois a senha,
que, claro,
vou copiar do portal e usar o terminal
e pressionar enter. E então eu vou ver aqui,
Logan teve sucesso. Agora eu acabei de limpar a
tela para que pudéssemos ter uma nova tela. Mas uma alternativa para usar
o login do docker
seria usar o
comando bash como login. Depois de fazer
isso, você vai
superar isso, zero. Autenticação
contra a Microsoft como zeros e uns em que você está
autenticado. Você pode então ver se
é o login do ACR
e, em seguida, especificar o nome do registro ao
qual
você está se conectando, o que seria: é grosseiro? E você não precisa instalar o
servidor de login completo, basta dizer o nome
do registro e isso faria com
que você entrasse no
registro da mesma forma. Então, essas são duas maneiras pelas
quais você pode realmente prosseguir e se autenticar. Agora, vamos ver como
empurrar a imagem. Então, vou usar a imagem
do docker para nossa ferramenta de microsserviço apenas porque ela tem
um nome mais curto, é mais fácil
usar esse nome. Tudo bem, então, o segundo passo do
microsserviço, é
isso que vamos promover para instigar a história. Então, vamos começar
com essa tag docker de comando. E então eu fui
especificar o nome e a
versão correspondente porque não
falamos sobre elitismo. Então, estou apenas especificando
a versão aqui. E eu o estou marcando com um alias relativo ao endereço de registro que eu quero que ele seja encontrado. Tudo bem, então o que isso significa? Isso significa que estou pegando essa imagem local
e vou enviá-la para esse endereço
neste repositório, e ela deve ser chamada assim. Agora,
ao não especificar uma tag, ela será automaticamente
marcada como a mais recente. Então, é claro, se eu
quiser manter a mesma versão, posso simplesmente
especificar a versão de acordo. Bem, eu fui deixar essa
versão desse funil. Então, quando eu faço essa
tag, eu pressiono Enter. O segundo passo
seria fazer um empurrão. Então, eu queria dizer Docker push. E então eu vou enviar a imagem
do
contêiner com alias nulo. Tudo bem? E então isso agora se conectará novamente
ao nosso registro. Ele usará a tag
padrão latest e a enviará para esse endereço. Então essa barra de registro, isso é o que chamaremos de
repositório e esse nome. Então, quando isso for concluído, se eu voltar para
o portal e olhar nos repositórios, não
vou ver que
tenho isso como nosso repositório. E quando eu clicar nela, verei que
tenho a tag mais recente aqui associada a essa imagem. Tudo bem, e a partir daqui eu posso realmente fazer uma
pesquisa se eu
quiser e retirá-la
do registro à vontade. Essa é uma boa maneira de
manter
seus aplicativos em
contêineres e em um registro para que
os desenvolvedores possam acessá-los
quando estiverem prontos. E você vê isso quando você tem
uma equipe que gira e tem
configurações ambientais complexas. Isso é muito,
muito importante e fácil usar, porque então
eles podem simplesmente retirar essas imagens e fazer com que o aplicativo seja executado em seu ambiente
com o mínimo de configuração. Então, se eu copiar isso e, em seguida puxar o docker logo em seguida, reiniciarei
o terminal e
colarei That's a dark pool
e ele será retirado direto do repositório com a
tag latest e pressionarei Enter. Em seguida, você pode ir
até a lista de imagens na
interface mais escura do Docker Desktop e verá essa imagem
aqui disponível para uso. Tudo bem, então eu posso simplesmente clicar nele
e iniciar a execução
do aplicativo ou usar meu comando docker run,
que eu prefiro usar, e começar a usá-lo. Agora, outra maneira de ver todas as imagens que
você tem é
usar o comando docker images. E isso
listará todas
as imagens atualmente disponíveis, bem
como seus IDs. Então, se eu quisesse
remover uma imagem, digamos que eu quisesse remover a versão 1.0 do meu computador. Eu posso pegar esse valor de identificação. Então eu posso ver um RMA mais escuro, que é a abreviação de remover
imagem e colar nesse ID, e então ele a excluirá para mim. Da mesma forma, se eu estiver
usando o Docker Desktop, sempre
posso ir até a
imagem e pressionar o botão. Então você vê que pode
equilibrar entre o material da interface e os comandos. Mas pelo menos agora
sabemos como enviar nossa imagem para nosso registro
no Microsoft Azure. Então, podemos fazer
quantos pools
precisarmos com base nesse registro. Mais uma vez, isso é
ótimo para a organização. Todos os quatro contêineres em
diferentes aplicações. Essa é a nossa equipe de desenvolvimento talvez precise acessá-la à
medida que avançamos.
9. Instâncias de contêineres do Azure: Então, agora vamos voltar ao nosso portal e acessar nosso serviço de Registro
de Contêineres. Agora temos o conceito de realmente provisionar a
imagem como um contêiner. Fizemos isso localmente, vamos fazer isso na nuvem. Agora, existem várias maneiras. A maneira mais fácil que vou mostrar
nesta lição é
usar as instâncias como seu
contêiner. Isso nos permite
provisionar contêineres em tempo real com base em uma imagem e ela
seria hospedada na nuvem. Então, se eu pular
para os repositórios e olhar nossa
imagem publicada aqui, você verá que tem a
opção de acessar a tag, a versão específica
que você deseja. E então você pode ver as instâncias de
execução serem
implantadas no aplicativo web. Então, vamos fazer as duas coisas. Vamos começar
com a instância Ron. Aqui. Ele lançará a lâmina de criação
da Instância
de Contêiner. Então, vou chamar
esse microserviço de dash two porque é o
único que esclarecemos. Microservice dash two,
deixaremos tudo como padrão, usaremos o mesmo grupo de recursos,
o local apropriado. Podemos especificar os
recursos que queremos para esse contêiner e podemos especificar se queremos um endereço IP
público. Eu vou dizer que sim. E vou deixar que seja
transmitido na porta 84 agora. E vamos
em frente e clicar em Criar. E quando o
processo de criação for concluído, podemos passar
para o recurso. E a partir daí, temos nosso aplicativo de microsserviço provisionado em
Container Instances. Então, aqui podemos reiniciar, parar, remover esse contêiner. E veremos aqui que
temos um contêiner em
execução no serviço de
instâncias de contêiner e temos um endereço IP público. Agora, você pode obter um nome
totalmente qualificado, mas geralmente define esse valor ao
passar pela configuração do
assistente de porto, passando pelas
etapas normais,
nas quais é configuração do
assistente de porto necessário preencher tudo,
o básico e a
rede, top, etc., etc., etc., etc. ou se você usa o comando. Então, por enquanto, seguimos
o caminho mais fácil e
podemos pedalar para trás e
ver a aparência do mago. Mas, por enquanto,
vou navegar até
a API diploid por
meio desse endereço IP público. Então, se eu abrir uma
nova guia e digitar esse endereço IP público
e simplesmente digitar endpoint da previsão do tempo. Já que essa é a única
coisa que existe. E deixe-me corrigir minha ortografia e tentar novamente. Lá vamos nós. Então, aqui estamos acessando a API diploide dentro
desse contêiner. E esse contêiner está sendo executado em nosso
serviço de Instância de Contêiner na nuvem. Obviamente, se adicionarmos um nome de domínio totalmente
qualificado, poderemos
aquecê-lo por meio desse endereço. Agora, basta gastar
um pouco e ir até
o assistente para criar
uma instância de contêiner. Se você olhar,
preencha as informações básicas, nós já sabemos tudo isso. Temos várias opções de distorção, mas a disponibilidade
é relativa à nossa região. Portanto, você pode ler mais sobre
isso por seu próprio motivo. Se você não está vendo
o que gostaria. Podemos escolher nossa fonte de imagem. Podemos ter as
imagens do Quickstart, nas quais
podemos escolher apenas uma
dessas amostras. Ou podemos
escolher entre nosso registro, que é basicamente o que fizemos. Então, poderíamos simplesmente procurar o registro apropriado e, em
seguida, a imagem apropriada
e, em seguida, a
versão apropriada que desejamos. Podemos mudar o tamanho
do contêiner. E então podemos
examinar outros registros, sejam eles públicos
ou privados e fornecer as
credenciais adequadamente. Agora, é claro, provavelmente é melhor ter tudo no Azure e não ter algumas coisas no Docker Hub
e outras no zero. É claro que, com base em seus joelhos, em sua arquitetura
e em sua organização, você quer tomar as
melhores decisões possíveis. Mas, como esse é um curso para
zero desenvolvedores, vamos direcionar tudo para
manter
tudo na Europa que a
Microsoft faz. Agora, para a parte de rede, podemos escolher um endereço IP público, privado ou nenhum. Também podemos escolher esse rótulo de
domínio, esse nível de DNS. Tudo bem? Portanto, o rótulo de nome DNS para o endereço IP público
fará parte de um nome de domínio totalmente qualificado ou FQDN que pode ser usado para
acessar o contêiner. Então essa era a peça que
faltava com o outro método que usamos para criar esse ACI ou
contêiner para nossa imagem. Se saltarmos para o avançado, veremos que temos uma certa quantidade de oxigênio de orquestração aqui. Assim, podemos configurar nossa política de
reinicialização, na qual
dizemos se talvez haja uma
falha ou algo aconteça, eu quero reiniciar
o contêiner? Posso dizer que, se algo acontecer, reinicializações sempre significam que
haverá uma reinicialização periódica. Nunca significa que
funcionará até eu pará-lo. E então, é claro, depois de
colocar tudo isso, podemos seguir em frente
e criar notas. Você também pode especificar suas variáveis de ambiente para esse contêiner específico
que você está criando. Portanto, todas as Instâncias de
Contêiner funcionam
em nossas Instâncias de
Contêiner do Azure. Agora, é claro, havia
uma opção em que
poderíamos implantá-lo em um aplicativo da web. Então, quando
voltarmos, veremos
um serviço de aplicativo Web zero
com contêineres.
10. Publicar em instâncias de contêiner do Azure: Nesta lição,
exploraremos as nuances
da criação de um contêiner como
seu serviço de aplicativo Web. Na verdade, não
vamos criá-lo. Vamos apenas
examinar algumas
das diferentes configurações que
precisamos conhecer. Então, quando eu clico em Criar, vamos para o básico. É claro que sabemos que preenchemos as informações básicas
com nosso grupo de recursos. Vou dar
esse nome específico. Eu só vou dizer
microservice dash two dash. Algo único que tenho certeza de que ninguém mais
na Internet tem. E então, como
vamos publicar? Então, até agora,
analisamos o código. E se eu for para o contêiner
Docker? Então, se eu clicar no contêiner Docker e perceber que ele
vai me perguntar qual sistema
operacional
estamos usando as notas até agora, então não há necessidade de mudar isso. Vou usar a melhor
região com base nas minhas necessidades. E então eu vou especificar
uma nova planta de serviço. Portanto, observe que não posso usar o plano Code Service porque o modelo de hospedagem é
diferente quando está frio, então podemos reutilizar o
plano de serviço existente que
tínhamos no início deste curso. Como estou escolhendo o contêiner
Docker, no entanto, preciso criar um novo e não
sou do tipo que opta
pelo preço premium. Ainda posso obter
o preço gratuito, então vou escolher esse. E então, se formos
para a banheira mais escura
, teremos várias
opções aqui. Posso escolher um único contêiner
em vez de um Docker Compose. E observe que
ainda está em pré-visualização. Então, se eu escolher um único
contêiner que me permita especificar
a fonte da imagem, eu quero usá-lo
do Docker Hub, algum outro registro privado. Então, uma faixa inteira mais escura, ECR ou zero
Container Registry. Esses não são os
únicos dois registros. E às vezes você pode
acabar provisionando seu próprio registro em seu
próprio ambiente, certo? Então, essas são todas as opções. Mas se eu escolher meu Registro de
Contêiner do Azure, posso então
selecionar o registro, selecionar a imagem e sua tag. Posso definir um
comando de inicialização, se quiser. Passe para o networking. Eu sou que praticamente todo o
resto permanece o mesmo. Tudo o que você
já está acostumado com
está familiarizado quando
se trata de aplicativos web do Azure. Usar a carga de trabalho mais escura do Azure Web App Service seria uma
barra muito semelhante, pois não, estamos usando contêineres docker. E, claro, quando se
trata de atualizar as tags desenvolver e implantar
continuamente, todas essas são opções que estão disponíveis para nós quando
provisionamos isso. No entanto, por questões de tempo e custo, não
vou prosseguir. É claro que você pode
prosseguir com um nível gratuito. Mas lembre-se de que o Container Registry e Container Instances estão custando caro. Assim, você pode experimentar
e obter todas as informações de que
precisa de acordo. No entanto, vou parar por aqui. Então, quando
voltarmos, daremos
uma breve olhada no Kubernetes 0s, apenas uma teoria. Mais uma vez, este não é um curso aprofundado sobre
Docker e orquestração. Há muito a aprender. Eu só queria
dar uma ideia de como os contêineres funcionam bem. Podemos colocar nossas
imagens no Azure e agrupar instâncias de aplicativos
com base nessas imagens. Então, quando
voltarmos, examinaremos algumas teorias sobre o
Kubernetes 0s e
entenderemos como ele
funciona nesse contexto atual.
11. Visão geral de serviço do Azure Kubernetes: Tudo bem, pessoal,
então, nesta lição vamos examinar
algumas das noções básicas sobre o
Kubernetes como apenas uma teoria. Não vamos
entrar no Kubernetes,
é um jogo totalmente diferente. Portanto, não vamos entrar em detalhes
nem discursos, mas quero que você por que normalmente ouve falar do Kubernetes é
sempre que ouve falar de obscuridade e conteinerização. Kubernetes oferece um mecanismo
confiável de agendamento e orquestração para cargas de trabalho de
aplicativos tolerantes a falhas. Isso é um monte de palavras
importantes para dizer que isso nos
oferece a capacidade gerenciar
contêineres inteiros quando provisionados, o fornecimento reiniciado
com base em métricas diferentes. Então, podemos realmente
usar o Kubernetes para configurar regras diferentes para gerenciar ou orquestrar nossos
contêineres. Mais uma vez, para aplicativos nativos da
nuvem ou
baseados em microsserviços, isso é muito importante
porque há várias partes móveis
que precisam estar saudáveis, provavelmente precisam ser
escaladas individualmente. Então, usando o Kubernetes,
podemos orquestrar tudo isso. Podemos dizer a um
dos serviços que
precisamos de três contêineres
durante o dia. Outro precisa de
outro, nunca precisa escalar. Tudo isso é
possível com o Kubernetes. Para fazer isso, usamos uma abordagem
declarativa, que nos permite usar essa abordagem declarativa
para lidar com implantações. E é apoiado por um conjunto robusto de APIs para nossas necessidades
de gerenciamento. Ele fornece gerenciamento de contêineres para organizar,
adicionar, remover ou atualizar para vários
contêineres no momento. Agora, quando usamos o
Kubernetes, podemos abstrair tarefas úteis,
como autorrecuperação, escalabilidade,
gerenciamento de rede, armazenamento, atualizações de
contêineres e gerenciamento de
segredos. Agora, a razão pela qual essa lista é significativa é que vimos que alguns
desses desafios
quando
analisávamos a conteinerização aumentaram. Tudo bem. Percebemos que estamos
muito atentos a qual endereço
IP, ou melhor, qual número de
porta foi atribuído
a cada contêiner. Tivemos que ver o quão bem, não
fizemos isso
nesses exercícios baseados na
arquitetura de microsserviços. Às vezes, os serviços
precisam conversar entre si, então definitivamente
precisamos saber como eles vão se conectar uns
com os outros. Como vamos lidar com o
armazenamento ou vamos atualizar o contêiner quando
a imagem do contêiner for atualizada? Como reiniciamos o contêiner para lidar com essa nova
versão da imagem? Então, sentindo que, se algo
parecer,
reiniciamos, vimos que podemos
fazer parte disso
usando as
Instâncias de Contêiner on-line. E, claro, se nos sentarmos e nos
sentarmos sozinhos, provavelmente
poderemos fazer isso. Mas por que dizemos a
nós mesmos que quando podemos usar o Kubernetes é automatizado? Agora, este é um comentário mais
uma vez da documentação da
Microsoft. É uma visão geral rápida de como nosso Kubernetes é
o que chamaremos de cluster. Você também pode ver os especialistas na aparência principal do cluster de TI. Então, a partir daqui, temos
o plano de controle. É aqui que toda a nossa lógica de
orquestração ficaria. E então temos cubelets
ou instâncias-chave. E cada um deles
tem o contêiner. É visto como um nodo. E tem tempo de execução para que
o contêiner e
o proxy se comuniquem
com o plano de controle. E então,
quantos contêineres existirem, o Kubernetes mais
uma vez orquestrará
e gerenciará todos eles. Agora, é claro, se tivermos Kubernetes,
teremos um Azure Kubernetes
Service ou AKS, para abreviar. Portanto, isso nos oferece uma maneira
rápida de desenvolver e implantar
aplicativos em contêineres em um piscar de olhos. Então, vimos como era rápido e
fácil com o ACR e o ACI. Bem, é ainda mais fácil e robusto se colocarmos o AKS na mistura. E isso nos dá todo
o poder da
orquestração do Kubernetes apoiada pela Microsoft como sua
infraestrutura. É um serviço pré-pago. E, mais uma vez, a escalabilidade
e todas essas coisas estão no Twine. Esse
serviço é totalmente gerenciado, então não precisamos nos
preocupar com nenhum software e hardware subjacentes. E oferece mais recursos de
orquestração e gerenciamento do que o ECI
ou o Container Instances. Vamos pensar nisso como
um serviço de gerenciamento ou extensão
de serviço de gerenciamento
para nosso serviço ACI. Então, mais uma vez, todos
esses serviços podem se unir para nos
ajudar a fornecer um
aplicativo em contêineres que é apoiado por uma orquestração
e escalabilidade adequadas. Então, agora que temos
uma apreciação do Kubernetes, pelo menos do ponto
de vista teórico. Vamos voltar
ao zero limpar nossos recursos e ver como podemos liberar espaço e economizar algum dinheiro.
12. Limpeza de recursos: Portanto, ao nos aproximarmos do
final desta seção, queremos garantir
que limparemos nossos recursos e não gastemos mais dinheiro do que o
necessário em nossa assinatura do Azure. Mesmo que você não tenha conseguido acompanhar algumas plantas
de ervilha, pelo
menos você entende
os conceitos e veremos como
podemos remover os recursos. Portanto, a maneira mais fácil de
remover nossos recursos acessar o recurso, é
claro, e clicar em Excluir. Agora, se você tiver outros recursos no
mesmo grupo de recursos, você sempre pode simplesmente
excluir o grupo de recursos e isso destruiria todos
os recursos adequadamente. Agora eu tenho algumas
coisas importantes nesse grupo de recursos, então não estou disposto
a seguir esse caminho. Em vez disso, vou excluir
os recursos individualmente. Então, para excluir nosso
Container Registry, vou clicar em Excluir. Tem certeza de que deseja excluir? Ok, e então
isso acionará a operação de exclusão. Da mesma forma,
vou até a Instância de Contêiner para obter
a ferramenta de hífen de microsserviço. E eu vou excluir
isso também. Também vou revisitar uma operação anterior em
que excluímos as imagens. As imagens ocupam espaço. Você pode ver se você digita
no comando docker images, todas as imagens que você tem no seu computador e seus
respectivos tamanhos por imagem. Portanto, se você não precisar da imagem, basta removê-la. Tudo bem? Então, aqui você vê que a imagem
do SQL Server é de 1,33 gb. E depois algumas das imagens dos aplicativos
nos quais estávamos trabalhando. Todos eles têm
uma probabilidade total combinada de
mais de um gigabyte. Portanto, para remover uma imagem, basta clicar duas vezes
no ID da imagem e copiá-lo. E então, no comando, você digita RMI mais escuro, abreviação de remover
imagem, digita esse ID, pressiona Enter e, em seguida, ele o removerá. Então você pode conseguir uma terra uma vez. Vamos ver qual é essa resposta. Uma resposta do conflito do D11
sobre a possibilidade de excluir
isso deve ser forçada enquanto
está sendo usada. Então, se você precisar forçá-lo
, vamos redigitar esse comando. Docker é um F louco, e então isso
forçará a exclusão. Tudo bem, então essa é outra maneira de limpar alguns
dos recursos que você provavelmente
teria evitado durante esta seção. Então, vamos encerrar esta
seção do curso.
13. Conclusão: Então, nesta seção, aprendemos sobre conteinerização
e escurecimento. E percebemos que a Docker
é uma tecnologia que tem, uma empresa que fornece tecnologia e
estabeleceu um padrão para conteinerização em todo
o setor de TI. Ao explorar a
conteinerização e o sombrio, analisamos como podemos colocar em
contêineres um projeto.net Core. Analisamos
o uso do arquivo Docker. Analisamos o fornecimento de recursos de suporte
adicionais e até mesmo algumas histórias
orais sobre
o uso do Docker Compose. Também analisamos
como podemos implantar nossos aplicativos nas Instâncias de
Contêiner do Azure e como podemos carregar nossa imagem, nossas imagens
de contêiner em um registro. Nesse caso, nos concentramos no
Azure Container Registry. Mas se você estiver usando o
Docker Desktop, é muito fácil enviar o Docker Hub se você quiser
usá-lo como seu registro. Também fizemos uma rápida análise do Kubernetes e da orquestração de
contêineres e o que tudo isso significa. Então, obrigado
por ler esta seção comigo. Te vejo no próximo módulo.