Feat/docker

package.json

@@ -0,0 +1 @@
+{}

stack/auxiliares/docker/build.md

@@ -0,0 +1,55 @@
+---
+order: 4
+icon: tools
+label: "Fazendo o build"
+author:
+  name: Pedro Santos
+date: 2025-10-28
+category: Explicação
+tags:
+  - explicacao
+  - images
+---
+
+# Fazendo a build de uma image
+
+Com uma dockerfile em mãos, prosseguimos para construir, ou fazer o build de uma image. O comando usado para isso é o comando `docker build`, que segue o formato:
+
+`docker build [OPTIONS] PATH | URL`
+
+Onde `[OPTIONS]` indica as flags e `PATH|URL` indica o contexto de execução, que pode ser um diretório local ou um repositório remoto.
+
+O comando build busca um arquivo com o nome Dockerfile dentro do contexto de execução e o usa para construir a image, por isso é mais conveniente sempre usar esse nome. Abaixo estão algumas flags interessantes que podem ser usadas para modificar o comportamento do comando build. A documentação introdutória para este assunto pode ser acessada em https://docs.docker.com/get-started/docker-concepts/building-images/build-tag-and-publish-an-image/.
+
+## Flags frequentemente usadas
+
+`--no-cache`: assegura que a build seja totalmente refeita, ignorando o cache de execuções prévias.
+
+`-f <file>`: faz com que o docker busque e utilize o arquivo de nome `file` para a construção, ao invés de buscar o arquivo de nome padrão Dockerfile.
+
+`--label <variable>=“<value>”`: permite adicionar metadados à build.
+
+-`t <name>:<tag>`: adiciona tags à imagem, como nome e versão, caso não seja especificado o docker sempre utiliza a tag “:latest” como padrão.
+
+## Comandos relacionas à images
+
+Aqui estão alguns comandos mais frequentemente utilizados para gerenciar images docker.
+
+-`docker image ls`: lista as images presentes no sistema.
+
+-`docker image pull [OPTIONS] NAME[:TAG|@DIGEST]`: faz download de uma image em um registro remoto.
+
+-`docker image push [OPTIONS] NAME[:TAG]`: faz upload de uma image para um registro remoto.
+
+-`docker image rm [OPTIONS] IMAGE [IMAGE...]`: remove uma ou mais images.
+
+-`docker image tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]`: cria uma nova tag para uma image já existente.
+
+## Retomando o exemplo
+
+Para fazer a build do servidor python simples demonstrado na seção anterior, utilizamos o seguinte comando, notando que é necessário estar no mesmo diretório que a dockerfile.
+
+`docker build -t python-server:v1 .`
+
+Utilizamos a flag `t` para nomear a image python-server, com a tag v1. Use o comando `docker image ls` para verificar que a image está de fato no seu sistema.  
+

stack/auxiliares/docker/compose.md

@@ -0,0 +1,124 @@
+---
+order: 1
+icon: versions
+label: "O compose"
+author:
+  name: Pedro Santos
+date: 2025-10-28
+category: Explicação
+tags:
+  - explicacao
+  - images
+  - compose
+---
+
+# O que é Docker compose
+
+Docker compose é uma ferramenta para definir e manter aplicações multi-container. Esta ferramenta facilita a manutenção
+da aplicação, suas redes e volumes, ao permitir a configuração em um único arquivo YAML.
+
+## Instalação
+
+Para instalar o plugin do docker compose, basta usar o seguinte comando:
+
+```bash
+sudo apt-get install docker-compose-plugin
+```
+
+## Exemplo
+
+Este exemplo foi copiado da documentação oficial do docker compose, disponível em https://docs.docker.com/compose/gettingstarted/#step-1-set-up.
+
+```bash
+ mkdir composetest
+ cd composetest
+```
+
+```python3 app.py
+import time
+
+import redis
+from flask import Flask
+
+app = Flask(__name__)
+cache = redis.Redis(host='redis', port=6379)
+
+def get_hit_count():
+    retries = 5
+    while True:
+        try:
+            return cache.incr('hits')
+        except redis.exceptions.ConnectionError as exc:
+            if retries == 0:
+                raise exc
+            retries -= 1
+            time.sleep(0.5)
+
+@app.route('/')
+def hello():
+    count = get_hit_count()
+    return f'Hello World! I have been seen {count} times.\n'
+```
+
+```requirements.txt
+flask
+redis
+```
+
+```docker Dockerfile
+FROM python:3.10-alpine
+WORKDIR /code
+ENV FLASK_APP=app.py
+ENV FLASK_RUN_HOST=0.0.0.0
+RUN apk add --no-cache gcc musl-dev linux-headers
+COPY requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+EXPOSE 5000
+COPY . .
+CMD ["flask", "run", "--debug"]
+```
+
+Até agora estes foram os passos padrão para definir uma image, para usar o compose é preciso criar um arquivo de configuração YAML.
+
+```yaml compose.yaml
+services:
+  web:
+    build: .
+    ports:
+      - "8000:5000"
+  redis:
+    image: "redis:alpine"
+```
+
+Esse arquivo define 2 serviços, `web` e `redis`. O serviço `web` utiliza dockerfile presente no diretório para fazer o build, e utiliza uma conexão entre as portas do container e uma porta externa.
+
+## Building
+
+Para fazer o build usando o docker compose, use o comando:
+
+`docker compose up`
+
+É possível utilizar as flags para execução de container no docker compose, por exemplo, `-d` faz com que os containers rodem no background.
+
+## Alguns comandos interessantes
+
+A lista completa de comandos pode ser acessada em https://docs.docker.com/reference/cli/docker/compose/.
+
+-`docker compose down [OPTIONS] [SERVICES]`: Interrompe e remove containers, redes e volumes criados por um comando `up`.
+
+-`docker compose images [OPTIONS] [SERVICE]`: lista as imagens utilizadas por containers.
+
+-`docker compose kill [OPTIONS] [SERVICE]`: força a interrupção de containers.
+
+-`docker compose ls [OPTIONS]`: lista os projetos compose sendo executados.
+
+-`docker compose ps[OPTIONS] [SERVICE]`: lista e fornece informações acerca dos containers em um projeto compose.
+
+-`docker compose pull [OPTIONS] [SERVICE]`: faz download de uma image associada a um serviço definido por um arquivo `compose.yaml`.
+
+-`docker compose up [OPTIONS] [SERVICE]`: builda, cria e inicia containers para um serviço.
+
+## Documentação para YAML
+
+A documentação para os arquivos `compose.yaml` é extremamente extensa, a documentação oficial pode ser acessada em https://docs.docker.com/reference/compose-file/. 
+

stack/auxiliares/docker/conceitos_importantes.md

@@ -0,0 +1,29 @@
+---
+order: 6
+icon: book
+label: "Conceitos"
+author:
+  name: 
+date: 2025-10-28
+category: Conceitos importantes
+tags:
+  - fundamentos
+  - explicacao
+---
+
+# Antes de iniciar...
+
+Antes de iniciar a explicação sobre como usar docker para desenvolver suas aplicações, é necessário falar sobre alguns conceitos essenciais para a compreensão dos próximos tópicos. A documentação introdutória oficial para este assunto está disponível em https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/.
+
+# Docker images
+
+Container é como chamamos os processo sendo executado por uma máquina, mas como o container sabe qual é sua tarefa e quais são as dependencias necessárias para executar tal tarefa? Utilizando uma image.
+
+Uma image é como chamamos o pacote que inclui os arquivos binários, dependências, bibliotecas e configurações para um container. Em termos da programação orientada à objetos, a docker image é uma classe, e os containeres são instâncias dessa classe.
+
+É importante notar que images são imutáveis, uma vez criadas, só podem ser alteradas adicionado mudanças ou criando uma nova image do zero. Além disso, images são construídas em camadas, cada camada representa uma mudança no sistema de arquivos, adicionando, removendo ou modificando arquivos.
+
+# Docker regsistry
+
+Para compartilhar docker images, há os docker registries, plataformas que permitem armazenamento e compartilhamento de images, de modo similar ao github, mas exclusivas para images. O registro oficial do docker é o DockerHub, que pode ser acessado em https://hub.docker.com/. Há outros registros, por exemplo, as grandes empresas fornecedoras de computação em nuvem, como Amazon (Amazon Elastic Container Registry) , Microsoft (Azure container registry), e Google (Google Container Registry) também oferecem registros para containeres.
+

stack/auxiliares/docker/containers.md

@@ -0,0 +1,69 @@
+---
+order: 3
+icon: rocket
+label: "Executando um container"
+author:
+  name: 
+date: 2025-10-28
+category: Explicação
+tags:
+  - fundamentos
+  - explicacao
+---
+
+
+# Rodando containers
+
+Se já temos uma image, podemos executar um container a partir dessa image, para isso, utilizamos o comando `docker run`, que tem o seguinte formato.
+
+`docker container run [OPTIONS] IMAGE [COMMAND] [ARG...]`
+
+Caso o docker não encontre localmente a image que você deseja rodar, ele fará uma busca no registro remoto configurado, o registro padrão é o dockerhub. A documentação introdutória oficial para este assunto está disponível em https://docs.docker.com/get-started/docker-concepts/running-containers/publishing-ports/
+
+## Flags para o comando run
+
+Abaixo estão algumas flags frequentemente utilizadas para modificar o comando de execução.
+
+`--name <custom-name> <image>`: designa o nome `custom-name` ao container, caso não seja especificado, docker vai gerar um nome aleatório.
+
+`-p <host-port>:<container-port>`: conecta a porta `host-port` à porta `container-port` do container.
+
+`-d`: roda o container no background, ou seja, não ocupa o terminal atual.
+
+`-e <var>=<value>`: define uma variavel de ambiente.
+
+`--rm`: encerra o container quando a execução deste for concluida.
+
+`-- memory <value>`: especifica um limite de memoria para o container, caso o limite seja ultrapassado o container é encerrado.
+
+`-t`: conecta o terminal ao I/O stream do container.
+
+`-i`: permite enviar texto ao stdin(input padrão) do container.
+
+## Comandos úteis para o gerenciamento de containers
+
+Aqui estão alguns comandos frequentemente utilizados para o gerenciamento de containers.
+
+`docker ps`: lista os containers ativos.
+
+`docker kill <container-name>`: finaliza um container de maneira abrupta.
+
+`docker stop <container-name>`: finaliza um container, esperando um certo tempo por seu encerramento.
+
+`docker port <container-name>`: lista as portas utilizadas por um container.
+
+`docker stats <container-name>`: mostra os recursos atualmente utilizados pelo container.
+
+`docker rename <container-name> <new-name>`: renomeia um container.
+
+`docker restart <container-name>`: reinicia um container.
+
+## Retomando o exemplo
+
+Vamos rodar o servidor python que fizemos anteriormente, para isso, usamos o seguinte comando:
+
+`docker run -p 8000:8000 -d server.py`
+
+Verifique que o container está rodando utilizando o comando `docker ps`. Como nã utilizamos a flag `name`, nosso container recebeu automaticamente um nome aleatório.
+
+Há algumas formas diferentes de interromper o container. A maneira mais "graciosa", de acordo com o docker, é utilizando o comando `docker stop`, pois este envia um sinal de parada ao container e espera seu encerramento. Ao contrário do `docker stop`, o comando `docker kill` finaliza abruptamente um container, o que pode comprometer processos que não são fechados corretamente.