Docker Essencial para a plataforma .NET

		Instrutor Macoratti
	Curso Docker Essencial para a plataforma .NET (Bônus Kubernetes)
Clique aqui e faça o seu pedido (Receba via Download)

42 Vídeo Aulas em 8 Módulos com Projetos completos e atividades resolvidas

Aula gratuita : Módulo 1 - O Contexto do Docker Aula gratuita : Módulo 3 - Criando Contêineres

Apresentação e Conteúdo do Curso

Apresentando e contextualizando o Docker

1a. Introdução - 5:39 min.
- Apresentação do Curso

2a. Contextualizando o Docker - 6:17 min.
- Apresentação dos conceitos
- Virtualização
- Contêineres
- Porque usar contêineres

3a. Apresentando o Docker - 6:54 min.
- O que é o Docker
- Qual o objetivo do Docker
- Como o Docker Funciona
- O que é um contêiner
- Contêiner e Imagem
- Diferença Contêiner e Maquina Virtual
- Arquitetura Docker

Preparando o Ambiente

1a. Instalando o Ubuntu - 8:26 min.
- Preparando o ambiente
- Instalando a VirtualBox da Oracle
- Criando Máquina Virtual Linux
- Instalando o Ubuntu 18.04 LTS

2a. Instalando o Docker - 6:36 min.
- Instalando o Docker no Linux
- Opção - Docker for Mac
- Opção - Docker for Windows
- Docker para Linux CE no Ubuntu
- Instruções de instalação
- Verificando a instalação

3a. Instalando o .NET Core SDK - 4:59 min.
- O que é o .NET Core SDK 2.1
- Componentes do .NET Core SDK
- Roteiro de instalação no Ubuntu
- Verificando a instalação

4a. Instalando o VS Code - 5:11 min.
- O que é o Visual Studio Code
- Instalando o VS Code no Ubuntu
- Instalando as extensões: C#, C# Extensions
- Verificando a instalação

5a. Instalando o Docker for Windows - 5:48 min.
- Opção - Docker Desktop
- Requisitos para instalação no Windows
- Habilitando a virtualização e o Hiper V
- Opção Docker ToolBox for Windows
- Instalando o Docker Desktop no Windows 10
- Como funciona o Docker no Windows

6a. Usando o Docker no Windows - 5:33 min.
- Verificando o ambiente Docker no Windows
- Criando um contêiner Docker : hello-world
- Verificando as imagens locais
- Verificando os contêineres locais
- Opções de configurações Docker no Windows

Criando contêineres a partir de imagens prontas

1a. Criando Contêineres - 8:17 min.
- Criando contêiner a partir de imagens
- Usando o modo Cliente
- Ajustando o ambiente LInux
- Criando o contêiner hello-world
- Usando imagens prontas no Docker Hub
- Fluxo de criação do contêiner: docker run
- Verifiando o contêiner criado e as imagens

2a. Criando Contêineres - II - 9:50 min.
- Criando contêineres
- Executando comandos em contêineres
- Baixando imagens prontas do Docker Hub
- Características dos contêineres
- Comandos usados para os contêineres

3a. Comandos Docker : Nova Sintaxe - 3:50 min
- A nova sintaxe dos comandos Docker
- A nova forma de versionamento do Docker
- Como funciona a estrutura da nova sintaxe

4a. Contêiner: Mapeando portas - 7:40 min.
- Mapeando portas em contêineres
- Porque mapear portas
- Mapeando portas do contêiner para o exterior
- Como funciona o mapeamento de portas
- Comando Docker para mapear portas

5a. Contêiner : Mapaeando pastas - 8:14 min.
- Mapeando diretórios para um contêiner
- Porque mapear pastas
- Como funciona o mapeamento de pastas
- Comando Docker para mapear pastas

6a. Contêiner Docker com .Net Core - 11:48 min.
- Criando um contêiner usando uma imagem da Microsoft
- Criando uma aplicação .NET Core do tipo Console
- Usando a imagem microsoft/dotnet:2.1-sdk
- Usando os comandos NET CLI para criar o projeto Console
- Criando o contêiner no modo interativo
- Entrando no contêiner e verificando o ambiente

- Exercícios sobre Contêineres
- Resolução dos Exercícios

Criando e gerenciando Imagens

1a. Apresentando Imagens do Docker - 7:33 min.
- O que é uma imagem Docker
- Como funcionam as imagens
- Imagens são classes, contêineres são objetos
- O repositório de imagens Docker Hub
- A composição das imagens
- Imagens são formadas por camadas somente leitura
- Criando um contêiner a partir de uma imagem
- Os benefícios das imagens
- A estratégia : copy-on-write
- Como criar imagens : docker build -t <imagem>
- O arquivo Dockerfile

2a. Criando imagens usando Dockerfile - 14:18 min.
- Criando imagens customizadas a partir de imagens base
- Usando o arquivo Dockerfile
- O que é o Dockerfile e como funciona
- O processo de criação de imagens : build
- Os comandos Dockerfile
- Roteiro para criar imagem usando Dockerfile
- O comando docker built -t <imagem>
- Publicando imagens com : docker push

3a. Gerenciando Imagens - 5:53 min.
- Apresentando os principais comandos
- Aplicando os principais comandos
- Bainxando imagens, Criando imagens, exibindo imagens
- Inspecionando imagens, tagueando imagens
- Verificando o histórico da imagem
- Removendo imagens

4a. Criando uma aplicação ASP .NET Core MVC - 14:31 min.
- Verificando o ambiente
- Criando o projeto ASP .NET Core MVC
- Implementando um Repositório
- Criando as Views
- Buildando e executando o projeto ASP .NET Core MVC
- Testando a aplicação ASP .NET Core MVC

5a. Criar Imagem p/ a App. ASP .NET Core MVC - 10:51 min.
- Publicando a aplicação ASP .NET Core MVC
- Criando a imagem para a aplicação MVC
- Criando o arquivo Dockerfile na raiz do projeto
- Usando a imagem base : microsoft/dotnet:2.1-aspnetcore-runtime
- Criando um contêiner com base na imagem gerada

6a. Publicando Imagens 5:26 min.
- Publicando imagens criadas
- Enviando imagens no Docker Hub
- Criando uma conta no Docker Hub
- Usando repositórios públicos e privados
- Logando na sua conta e enviando a imagem
- Preparando as imagens
- Enviando as imagens para o repositório

- Exercícios sobre Imagens
- Resolução dos Exercícios

Apresentando e criando volumes

1a. Apresentando Volumes - 7:45 min.
- O que são os Volumes no Docker
- Como funcionam os volumes Docker
- Por que usar Volumes
- Persistindo informações usando Volumes
- Principais usos dos Volumes
- Criando Volumes no Docker

2a. Criando Volumes : DataBase MySQL - 12:16 min.
- Criando Volume no Docker
- Os principais comandos usados com Volumes
- Usando o volume em um contêiner MySQL
- Mapeando o volume para a pasta /var/bin/mysql
- Criando a imagem do MySQL usando a imagem base
- Criando um contêiner MySQL e usando o Volume
- Testando o contêiner MySQL e o volume criado

3a. Ajustar App MVC c/EF Core e acessar MySql - 16:05 min.
- Ajustando a aplicação ASP .NET Core
- Incluindo o EF Core para acessar o MySQL
- Criando um Repositório para dados
- Populando a tabela do MySQL usando Migrations
- Criando uma migração pendente para usar na inicialização
- Definindo a string de conexão com o MySQL

4a. Criar Contêiner MySQL usando imagem base - 5:26 min.
- Baixando a imagem do MySQL 5.7
- Verificando a seção Volumes da imagem
- Criando um Volume para armazenar dados
- Criar imagem MySql
- Criar o contêiner MySQL mapeando o volume

5a. Atualizar imagem App MVC - 7:33 min.
- Criando uma nova imagem para App MVC
- Publicando a aplicação
- Criando o Dockerfile
- Criando a nova imagem: docker build -t <img> .

6a. Conectando dois contêineres: MVC e MySQL 9:38 min.
- Criando o contêiner da app MVC
- Realizar a conexão com o contêiner MySQL
- Usando redes virtuais para conexão entre contêineres
- Obtendo o endereço IP do MySQL
- Criar o contêiner MVC mapeando para IP do MySQL
- Acessando o contêiner MySQL
- Verificando o banco de dados criado na migração

- Exercícios sobre Volumes
- Resolução dos Exercícios

Criando e customizando redes

1a. Apresentando Redes no Docker - 5:45 min.
- Conceitos sobre redes definidas por software
- As redes virtuais criadas pelo Docker
- As redes : bridge, none e host
- A comunicação entre contêineres via rede virtuais
- Inspecionando redes do docker
- Fluxo de comunicação usando rede virtual

2a. Usando redes virtuais 5:05 min.
- A rede padrão bridge do Docker
- Inspecionando os IPs atribuidos aos contêineres
- Verificando a comunicação entre os contêineres: ping
- Criando redes customizadas: docker network create

3a. Criando redes Customizadas no Docker - 7:50 min.
- Criando redes personalizadas
- Criando dois contêineres
- Fazendo a comunicação entre os contêineres
- Associando o contêiner a uma rede customizada
- Conectando um contêinere a uma rede

4a. Escalando a aplicação MVC usando redes - 5:45 min.
- Redes virtuais se comportam como redes físicas
- Escalando a aplicação criando contêineres
- Criando um novo contêiner para a aplicação MVC
- Acessando os contêineres na mesma rede em portas distintas
- Fluxo de comunicação da aplicação MVC

5a. Criando redes customizadas - 12:20 min.
- Usando redes customizada para comunicação entre contêineres
- Usando o comando : docker network create <nome_rede>
- Conectando um contêinere a uma rede customizada
- Criando as redes : frontend e backend
- Associando as redes às aplicações MVC e MySQL
- Conectando um contêiner a uma rede customizada
- Verificando a comunicação entre os contêineres via rede customizada

6a. Usando um balanceador de carga e escalar a app MVC - 5:27 min
- Usando um balanceador de carga HAproxy
- Criando o arquivo de configuração haproxy.cfg
- Criando um contêiner para o balanceador de carga
- Acessando a aplicação MVC via balanceador de carga

- Exercícios sobre Redes
- Resolução dos Exercícios

Usando o Docker Compose

1a. |Introdução ao Docker-Compose - 7:33 min.
- O que é o Docker-Compose
- Como funciona o Docker-Compose
- Porque usar o Docker Compose
- Gerenciando aplicações complexas
- Instalando o Docker-Compose no Linux

2a. Usando o Docker Compose - 7:32 min.
- Orquestrando os contêineres MVC, MySQL e LoadBalancer
- Definindo o ambiente
- Criando o arquivo de composição: docker-compose.yml
- Usando o formato YAML
- As seções do arquivo de composição: version, volumes, networks e services
- Processando o arquivo de composição : docker-compose -f build

3a. Criando o arquivo de composição - 9:03 min.
- Definindo a seção services para descrever os serviços
- Definindo os contêineres para o mysql
- Iniciando a descrição do serviço para criar o contêiner
- Usando as diretivas: image, volumes, networks, environment
- Processando o arquivo de composição : docker-compose build
- Processando o arquivo e inicializando os serviços : docker-compose up
- Removendo os contêineres, volumes e redes: docker-compose down -v

4a. Ajustando app MVC : Usando script SQL - 10:30 min.
- Definindo um script SQL para popular os dados iniciais
- Definindo o mapeamento do volume para o script criado no arquivo docker-compose
- Verificando a sintaxe : docker-compose build
- Verificando os contêineres criados e o log gerado
- Entrar no contêiner MySQL e verificar os dados criados
- Removendo tudo : docker-compose down -v

5a. Criando o serviço para o contêinere MVC - 11:44 min.
- Definindo o serviço mvc no arquivo docker-compose
- Definindo a seção mvc
- Definindo um build a partir do Dockerfile
- Definindo as redes virtuais
- Mapeando as portas para o contêiner
- Indicando a dependência do serviço mvc do serviço mysql
- Processando o arquivo docker-compose
- Testando a aplicação MVC acessando o MySQL

- Exercícios sobre Docker Compose
- Resolução dos Exercícios

Conteinerizando aplicações .NET Core

1a. Fazendo o Deploy no Contêiner - 13:36 min.
- Fazendo o deploy da aplicação MVC no contêiner Docker
- Criando uma nova imagem para deploy no contêiner
- Usando a imagem base: microsoft/dotnet:2.1-sdk
- Definindo o arquivo Dockerfile.dev
- Definindo o arquivo docker-compose.dev
- Criando a imagem customizada
- Processando o arquivo de composição

2a. Otimizando o arquivo Dockerfile - 6:59 min.
- Otimizando o arquivo Dockerfile e a imagem gerada
- Usando o recurso : multi-stage build
- Usando mais de um comando FROM
- Nomeando cada novo estágio usando a instrução AS
- Copiando os arquivos existentes em estágios anteriores

3a Aplicando o recurso: multi-stage build - 7:36
- Criando o arquivo Dockerfile.multi
- Criando o arquivo docker-compose.multi
- Processando o arquivo de composição

4a. Usando a extensão Docker no VS Code - 8:18 min.
- Instalando a extensão Docker no Visual Studio Code
- Gerenciando contêineres, imagens e repositórios no VS Code
- Acessando os comandos e sua documentação nos arquivos Dockerfile e docker-compose
- Gerando de forma automática o Dockerfile