- Fundamentos do Sistema Operacional
- Navegação e Gerenciamento de Arquivos
- Automatização com Scripts e Comandos
- Automação Avançada e Servidores Web
- Monitoramento e Execução Automática
- Configuração Inicial e Fundamentos da Comunicação Web
- URLs, Domínios e DNS
- Mensagens HTTP e Autenticação
- Segurança e Criptografia em Redes
- Protocolo HTTP e Evolução
- Criação e Conexão de Repositórios
- Trabalho com Branches e Merge
- Resolução de Conflitos e Pull Requests
- Integração Contínua com GitHub Actions
- Automatização com Dependabot
- Containers vs. Máquinas Virtuais e Instalação do Docker
- Gerenciamento de Containers com Docker CLI
- Estrutura de Imagens e Criação de Containers
- Persistência de Dados em Containers
- Integração com Serviços em Nuvem e Docker Compose
Nesta etapa abordei os conceitos fundamentais do sistema operacional:
- Entendendo que um sistema operacional exerce o papel de gerenciar a utilização dos recursos de um hardware: Compreensão do papel e importância do sistema operacional.
- Conhecendo as diferentes distribuições do Linux para selecionar a opção mais adequada em um determinado caso de uso: Análise e escolha das distribuições Linux.
- Instalando um sistema operacional em uma máquina virtual para realização de testes e estudos: Configuração de máquinas virtuais para testes.
- Utilizando o protocolo SSH para acessar servidores remotamente: Acesso remoto seguro via SSH.
Nesta etapa foquei na navegação e gerenciamento de arquivos:
- Navegando entre diretórios e arquivos no Shell CLI do Linux para encontrar e acessar informações armazenadas no sistema de arquivos: Comandos básicos de navegação no Shell.
- Movendo, copiando e removendo arquivos para organizar os diretórios do sistema: Gerenciamento de arquivos e diretórios.
- Listando e criando arquivos no Shell CLI para facilitar a manutenção de dispositivos como servidores: Listagem e criação de arquivos.
Aqui, explorei a criação e execução de scripts:
- Construindo e executando scripts no Shell CLI para realizar múltiplas tarefas de modo automatizado: Criação de scripts para automação de tarefas.
- Utilizando o comando tar para compactar e descompactar arquivos: Uso do comando tar para manipulação de arquivos.
- Implementando a passagem de parâmetros para dar opção de entrada ao usuário: Adição de parâmetros aos scripts.
- Utilizando a sintaxe condicional no Bash para direcionar a execução de blocos de instruções no programa: Uso de condicionais no Bash.
Nesta etapa abordei a automação avançada e servidores web:
- Implementando múltiplas ações em um único script para facilitar o processo de automação: Criação de scripts complexos para múltiplas tarefas.
- Construindo códigos que permitam ao usuário selecionar as tarefas que serão executadas pelo script: Interatividade em scripts.
- Selecionando e instalando um servidor web para hospedagem de sites e aplicativos: Instalação e configuração de servidores web.
Finalizei com monitoramento e execução automática de scripts:
- Verificando o status dos processos em execução no servidor para monitorar o seu desempenho: Monitoramento de processos no servidor.
- Utilizando operadores e comandos para filtrar e coletar dados a partir de textos: Filtragem e coleta de dados.
- Construindo scripts para monitorar o estado operacional de sistemas como servidores web: Criação de scripts de monitoramento.
- Executando scripts usando o crontab para implementar um cronograma de execução automática no sistema: Automação de tarefas com crontab.
Nesta etapa, configurei o projeto e explorei os fundamentos da comunicação web:
- Configurando o projeto de aplicação web All Books que será explorado ao longo do curso: Preparação e configuração inicial do projeto.
- Identificando o modelo cliente-servidor adotado na construção de aplicações web: Compreensão do modelo cliente-servidor.
- Entendendo que o protocolo HTTP atua na camada de aplicação para possibilitar a comunicação entre aplicações web: Estudo do papel do protocolo HTTP.
- Compreendendo como as redes de computadores estão organizadas para garantir que diferentes dispositivos computacionais sejam capazes de enviar e receber dados: Estrutura das redes de computadores.
- Analisando os componentes e características do protocolo HTTP que atua na camada de aplicação para transferência de dados na web: Análise do protocolo HTTP.
Nesta etapa, foquei em URLs, domínios e o sistema DNS:
- Analisando uma URL para identificar o protocolo, a localização e o tipo de recurso que estamos acessando na web: Desconstrução e análise de URLs.
- Configurando URLs para utilizar protocolos, domínios, portas e caminhos específicos: Configuração de URLs personalizadas.
- Usando nomes de domínios (em substituição aos endereços IP) para acessar diferentes recursos na Web: Uso de domínios para facilitar o acesso.
- Entendendo que o sistema DNS está hierarquicamente estruturado com diferentes servidores para resolução global de nomes de domínio em endereços IP: Compreensão do sistema DNS.
Aqui, explorei mensagens HTTP e mecanismos de autenticação:
- Interpretando a estrutura de mensagens HTTP e seus códigos de status para analisar o processo de comunicação entre cliente e servidor: Análise de mensagens HTTP.
- Depurando os métodos HTTP usando o Postman para ler e criar recursos no backend de uma aplicação web como o projeto All Books: Uso do Postman para testes de API.
- Usando mecanismos como cookies e sessões para relembrar constantemente aos servidores HTTP a identidade de um usuário: Implementação de cookies e sessões.
- Configurando cabeçalhos (headers) em requisições para o backend de modo a permitir o acesso a conteúdos que exigem a autenticação do usuário: Configuração de cabeçalhos para autenticação.
Nesta etapa, abordei segurança e criptografia:
- Monitorando o tráfego em uma rede para análise de erros, protocolos e aspectos de segurança: Monitoramento de tráfego de rede.
- Utilizando o OpenSSL na criação de chave e certificado digital para implementar criptografia no projeto All Books: Implementação de criptografia com OpenSSL.
- Implementando o HTTPS para proteger as mensagens trocadas entre cliente e servidor no projeto All Books: Configuração de HTTPS.
- Usando o Postman como ferramenta para testar o funcionamento de um servidor HTTP: Testes de servidor com Postman.
- Compreendendo como a criptografia atua para assegurar a integridade dos dados encaminhados na web: Estudo do papel da criptografia na segurança dos dados.
Finalizei com o estudo do protocolo HTTP e sua evolução:
- As camadas de segurança SSL/TLS atuando para proteção de dados na comunicação em rede: Entendimento das camadas SSL/TLS.
- Utilizando parâmetros nas requisições HTTP para obtenção e criação de dados em um servidor web: Uso de parâmetros em requisições HTTP.
- Os protocolos UDP e TCP da camada de transporte atuando na transmissão de dados entre dispositivos em uma rede: Estudo dos protocolos de transporte UDP e TCP.
- O protocolo QUIC sendo criado a partir do protocolo UDP para possibilitar a criação da versão 3 do protocolo HTTP, reconhecida pelo seu alto desempenho: Compreensão do protocolo QUIC.
- O protocolo HTTP evoluindo para tornar a comunicação web mais eficiente, segura e ágil: Evolução do protocolo HTTP.
Nesta etapa, configurei repositórios locais e remotos, além de entender as diferenças entre Git e GitHub:
- Criando um repositório git local com os comandos
git initegit branch -M maine o repositório remoto para poder compartilhar o seu código com outras pessoas: Inicialização e configuração de repositórios. - Conectando um repositório local com um remoto através do comando
git remote add origin URL: Conexão entre repositórios locais e remotos. - Entendendo que o Git e o GitHub são diferentes. Enquanto o Git é a ferramenta responsável pelo controle do versionamento de códigos, o GitHub é a plataforma responsável pelos repositórios: Compreensão das funções de Git e GitHub.
- Criando um commit para registrar as alterações realizadas no projeto com o comando
git commit -m "Mensagem que descreve as mudanças": Registro de alterações com commits. - Enviando e trazendo alterações feitas para os repositórios local e remoto por meio dos comandos
git push origin mainegit pull origin main: Sincronização entre repositórios. - Cuidando do fluxo de trabalho em projetos colaborativos usando os comandos Git, como
git status,git add,git commit,git push, egit pull: Gerenciamento de fluxo de trabalho colaborativo.
Nesta etapa, explorei o trabalho com branches e a integração de mudanças:
- Criando uma nova branch para trabalhar com ramificações em repositórios Git, através do comando
git checkout -b nova-branch: Criação de branches. - Entendendo como funcionam as branches e como elas ajudam a isolar mudanças para que o código principal não seja afetado: Isolamento de mudanças com branches.
- Realizando um merge de uma branch em outra usando o comando
git merge, para mesclar as alterações das duas branches: Integração de mudanças com merge. - Usando o Gitflow ou o Trunk Based para gerenciar as ramificações do seu projeto: Gerenciamento de ramificações com Gitflow ou Trunk Based.
Aqui, foquei em resolução de conflitos e revisão de código:
- Resolvendo um conflito, quando um mesmo arquivo é editado por duas pessoas diferentes, através da análise do código, para decidir o que manter e o que descartar: Resolução de conflitos de código.
- Criando uma issue para descrever e documentar as tarefas que devem ser feitas no ciclo de desenvolvimento de um software: Documentação de tarefas com issues.
- Usando o recurso de Pull Requests para solicitar a revisão de um código antes de ele ser integrado a outra branch: Revisão de código com Pull Requests.
Nesta etapa, explorei a automação de integração contínua:
- Definindo a Integração Contínua como a prática de automatizar as atualizações de código no repositório, para ocorrer integração no código-fonte e a execução frequente de testes com o objetivo de detectar e corrigir problemas de integração, o que é bastante importante no dia a dia de DevOps: Conceito de Integração Contínua.
- Aplicando a Integração Contínua através da configuração de um workflow do GitHub Actions: Configuração de workflows de CI com GitHub Actions.
- Testando e visualizando o funcionamento do workflow de Integração Contínua: Testes e monitoramento de workflows.
- Aplicando proteção de branches para garantir que todos os códigos integrados à main passem antes pela revisão através de um PR e que o código seja testado pelo workflow de CI: Proteção de branches e revisão de código.
Finalizei com a automação de segurança e atualizações usando Dependabot:
- Ativando alertas de vulnerabilidade nas dependências do projeto através do Dependabot: Monitoramento de vulnerabilidades com Dependabot.
- Automatizando a resolução das vulnerabilidades, configurando o Dependabot para tentar resolver e abrir Pull Requests com as resoluções: Automação de resolução de vulnerabilidades.
- Configurando a atualização automática de versões com o Dependabot: Atualizações automáticas de dependências.
Nesta etapa, aprofundei o entendimento sobre containers, sua função e instalação do Docker:
- Entendendo a diferença entre containers e máquinas virtuais como soluções de virtualização para isolamento de ambientes: Comparação entre containers e máquinas virtuais.
- Compreendendo que os containers compartilham o mesmo kernel do sistema operacional e isolam apenas processos do espaço do usuário: Funcionamento dos containers e isolamento de processos.
- Explorando como os containers constituem uma solução eficiente para encapsulamento de aplicações e suas dependências, mantendo seu conteúdo isolado do sistema do host: Encapsulamento de aplicações com containers.
- Instalando o Docker em um computador para utilizar a virtualização baseada em containers: Instalação do Docker.
- Entendendo a função dos namespaces na garantia de isolamento total dos containers em relação ao seu host: Papel dos namespaces no isolamento de containers.
- Utilizando os comandos do Docker para criação e verificação do status de containers: Operações básicas com containers usando Docker CLI.
- Reconhecendo o papel do Docker Hub como registry no armazenamento, gerenciamento e distribuição de imagens para criação de containers: Utilização do Docker Hub como repositório de imagens.
Nesta etapa, explorei o gerenciamento de containers com comandos do Docker:
- Atuando com o Docker como uma container engine para criação e gerenciamento de containers: Uso do Docker como motor de containers.
- Usando comandos da Docker CLI para iniciar, pausar, parar e retomar a execução de um container: Comandos para controle de execução de containers.
- Utilizando diferentes opções com o comando
docker runpara definir configurações no momento da criação de um container: Configuração de containers comdocker run. - Interagindo com containers em execução para utilizar a aplicação ou sistema operacional encapsulado: Interação com containers ativos.
- Realizando o mapeamento de portas para possibilitar o acesso externo à aplicação em execução dentro de um container usando o Dockerfile: Configuração de acesso externo via mapeamento de portas.
Nesta etapa, compreendi a estrutura de imagens e como criar e compartilhar containers:
- Estruturando imagens e containers em camadas para proporcionar eficiência na utilização de recursos e distribuição de aplicações: Estruturação em camadas de imagens e containers.
- Inspecionando a estrutura das imagens para analisar as principais características de suas camadas: Análise da estrutura de imagens Docker.
- Criando uma imagem utilizando o Dockerfile para implementar aplicações utilizando containers: Criação de imagens personalizadas com Dockerfile.
- Subindo uma imagem no Docker Hub para compartilhar com a comunidade ou para uso em outros ambientes: Compartilhamento de imagens no Docker Hub.
Nesta etapa, explorei diferentes métodos de persistência de dados em containers Docker:
- Explorando diferentes mecanismos de persistência de dados no Docker para garantir a continuidade e segurança das informações geradas por aplicações conteinerizadas: Mecanismos de persistência de dados em Docker.
- Criando e utilizando bind mounts, vinculando pastas no sistema host aos diretórios dentro dos containers, para implementar um mecanismo de persistência de dados: Persistência de dados com bind mounts.
- Gerenciando volumes no Docker para criar, utilizar e verificar a persistência de dados entre diferentes execuções de containers: Uso de volumes para persistência de dados.
- Adotando a persistência temporária usando
tmpfsao executar containers, compreendendo seu caráter temporário e sua aplicação em ambientes específicos: Uso detmpfspara persistência temporária.
Finalizei com a integração de containers com serviços em nuvem e coordenação com Docker Compose:
- Realizando a integração de aplicações conteinerizadas com serviços em nuvem para efetiva implantação da aplicação em um ambiente de produção: Integração de containers com serviços em nuvem.
- Criando uma conta de acesso para utilizar serviços em nuvem oferecidos pela Amazon: Configuração de conta AWS.
- Configurando instâncias no Amazon Elastic Beanstalk para a implantação de aplicações: Implantação de aplicações no AWS Elastic Beanstalk.
- Utilizando o Docker Compose com arquivos de configuração YAML para coordenar containers: Coordenação de containers com Docker Compose.
- Entendendo que o Docker Compose atua na coordenação de containers, enquanto ferramentas como Kubernetes e Docker Swarm assumem funções de orquestração: Diferença entre Docker Compose e orquestradores como Kubernetes e Docker Swarm.