anúncios

Mostrando postagens com marcador Docker. Mostrar todas as postagens
Mostrando postagens com marcador Docker. Mostrar todas as postagens

quinta-feira, 12 de fevereiro de 2026

Executando o Ollama no ambiente Docker

Executar o Ollama no Docker é a maneira mais prática de executar modelos de linguagem (LLMs) localmente, garantindo isolamento do sistema operacional e fácil gerenciamento.

O presente howto explica passo a passo para configurar o Ollama com Docker e instalar modelos, tanto com CPU quanto com GPU.

  1. Pré-requisitos
  2. A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

    Nvidia Container Toolkit (Para GPU): Se você tem uma GPU Nvidia e quer aceleração, instale o Nvidia Container Toolkit para o Docker reconhecer sua placa.

  3. Executar o Ollama no Docker
  4. Abra o seu terminal e utilize os comandos abaixo:

    A. Apenas CPU

    -d: Roda o contêiner em segundo plano (detached mode).

    -v ollama:/root/.ollama:

    Cria um volume chamado ollama para garantir que seus modelos baixados não sejam apagados quando o contêiner for reiniciado.

    -p 11434:11434:

    Mapeia a porta padrão do Ollama.

    B. Com GPU NVIDIA (Aceleração) docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama --gpus=all:

    Permite que o contêiner acesse a GPU.

  5. Instalar e Rodar Modelos Abertos (Ollama Pull/Run)
  6. Com o contêiner rodando, você pode "entrar" nele e baixar os modelos através da CLI (Interface de Linha de Comando).

    Download de um modelo (ex: Llama 3.2):

    docker exec -it ollama ollama pull llama3.2

    Executar o modelo e interagir:

    docker exec -it ollama ollama run llama3.2

    Agora você pode conversar com o modelo diretamente no terminal.

    Outros modelos populares:

    docker exec -it ollama ollama run gemma2

    docker exec -it ollama ollama run deepseek-r1

    docker exec -it ollama ollama run qwen2.5
  7. Como ver os modelos instalados e gerenciar
  8. Para listar os modelos que você já baixou dentro do contêiner Docker, use:

    docker exec -it ollama ollama list

    Para remover um modelo:

    docker exec -it ollama ollama rm nome_do_modelo
  9. Dica Pro: Interface Web (Open WebUI)
  10. Para ter uma experiência tipo "ChatGPT" com o Ollama no Docker, a melhor opção é o Open WebUI.

    Use o docker-compose para rodar o Ollama e a interface gráfica juntos:

    Crie um arquivo docker-compose.yml:

    
    services:
      ollama:
        volumes:
          - ollama:/root/.ollama
        container_name: ollama
        image: ollama/ollama
        ports:
          - "11434:11434"
        networks:
          - ollama-net
        restart: always
    
      open-webui:
        image: ghcr.io/open-webui/open-webui:main
        container_name: open-webui
        volumes:
          - open-webui:/app/backend/data
        ports:
          - "3000:8080"
        environment:
          - OLLAMA_BASE_URL=http://ollama:11434
        networks:
          - ollama-net
        restart: always
    
    networks:
      ollama-net:
    
    volumes:
      ollama:
      open-webui:
    
    

    Execute: docker-compose up -d

    Acesse http://localhost:3000 no seu navegador.

Feito!

sexta-feira, 9 de janeiro de 2026

Guia prático de redes Docker

Entenda o essencial e pare de sofrer

Por que redes Docker importam?

Contêineres são processos isolados. Para que conversem entre si e com o mundo externo, precisam de rede.

Quando você ignora esse ponto, surgem sintomas típicos:

  • "O container sobe, mas o app não conecta ao banco."
  • "Funciona no meu computador, mas não no servidor."
  • "Consigo acessar localhost, mas o container não."

Quase sempre, a raiz do problema é como a rede foi criada ou usada.

  1. O mapa mental das redes Docker (o que realmente existe)
  2. Quando você instala Docker, ele cria automaticamente três redes:

    Rede Descrição Quando usar Observações importantes
    bridge Rede padrão criada pelo Docker para comunicação entre contêineres no mesmo host. Desenvolvimento local e aplicações simples com múltiplos contêineres. Possui DNS interno; contêineres se comunicam pelo nome. É a base da maioria dos projetos com Docker Compose.
    host Remove o isolamento de rede; o contêiner utiliza diretamente a rede do host. Casos específicos de performance ou necessidade de acesso direto à rede do host. Elimina o mapeamento de portas. Reduz isolamento e aumenta riscos se usado sem critério.
    none Contêiner sem qualquer interface de rede configurada. Jobs isolados, processamento offline ou tarefas batch. Não permite comunicação externa ou interna. Uso pouco comum em aplicações web.

    Na maioria dos projetos, você vai trabalhar quase sempre com "bridge", normalmente criada com docker network create.

  3. Conceito-chave: DNS interno do Docker
  4. Este é o ponto mais ignorado, e o que mais causa problemas.

    Dentro de uma rede Docker:

    • Você não usa localhost para falar com outro contêiner.
    • Você usa o nome do serviço (ou nome do contêiner).

    Exemplo no docker-compose.yml:

    
    services:
      api:
        image: minhaapi
        depends_on:
          - db
      db:
        image: postgres:16
    
    

    A aplicação "api" deve conectar no banco usando:

    DB_HOST=db

    e não:

    DB_HOST=localhost

    Regra mental simples: no Docker, serviços conversam pelo nome.

  5. Portas: interna x externa (a confusão clássica)
  6. Quando você publica uma porta, faz um mapeamento:

    -p 8080:8080

    Leia assim:

    porta_do_host : porta_do_container

    -O contêiner continua ouvindo dentro dele (porta interna).

    -O host expõe a porta para fora.

    Se você esquecer o -p, o serviço funciona entre containers, mas não de fora para dentro, e parece "quebrado".

  7. Criando redes do jeito certo
  8. Crie explicitamente uma rede para seu projeto:

    docker network create minha-rede

    Quando subir containers:

    docker run -d --name api --network minha-rede minhaapi

    docker run -d --name db --network minha-rede postgres:16

    Agora ambos:

    Estão isolados de outros projetos.

    Podem se resolver por nome.

    Não "vazam" comunicação desnecessária.

  9. Compose: onde tudo fica mais limpo
  10. No docker-compose.yml, usar rede é natural:

    
    services:
      api:
        image: minhaapi
        ports:
          - "8080:8080"
        depends_on:
          - db
        networks:
          - appnet
    
      db:
        image: postgres:16
        networks:
          - appnet
    
    networks:
      appnet:
        driver: bridge
    
    

    Você ganha:

    • Organização
    • Reprodutibilidade
    • Zero dor com comandos longos
  11. Comunicação: quem enxerga quem?
  12. Contêineres na mesma rede -> conversam entre si.

    Contêineres em redes diferentes -> não conversam (a menos que você conecte).

    Host acessa container exposto via localhost:porta_publicada.

    Quer conectar um container a outra rede?

    docker network connect outra-rede api

  13. Banco de dados e "localhost": por que sempre falha
  14. Cenário comum:

    App Java no container

    Banco PostgreSQL no container

    Conexão configurada para localhost

    Resultado: erro.

    Explicação curta: "localhost" dentro do container aponta para ele mesmo, não para outro container.

    Use:

    jdbc:postgresql://db:5432/meubanco

    Simples assim.

  15. Debug rápido (checklist)
  16. Quando algo "não comunica", verifique:

    O container está na mesma rede?

    Estou usando nome do serviço, não localhost?

    A porta está publicada (-p) quando preciso acessar do host?

    O container de destino realmente está ouvindo na porta esperada?

    Compose não está criando uma rede automática diferente?

    Ferramentas úteis:

    docker network ls

    docker network inspect <nome>

    docker container inspect <nome>

  17. Boas práticas arquiteturais
  18. Uma rede por sistema (ou domínio lógico).

    Não expose banco de dados para fora sem necessidade.

    Use nomes estáveis de serviços.

    Documente portas e dependências.

    Prefira docker compose ao invés de comandos manuais.

  19. Mentalidade correta para redes Docker
  20. Ao desenhar um ambiente, pergunte:

    • Quem precisa falar com quem?
    • Essa comunicação é interna ou externa?
    • Existe risco se alguém fora enxergar este serviço?
    • Preciso compartilhar a rede com outros projetos?

    Responder isso antes evita retrabalho depois.

Considerações finais

Docker Networks não são complicadas, apenas exigem um modelo mental correto:

  • containers conversam por nomes
  • redes definem fronteiras
  • portas definem exposição
  • compose organiza tudo

Dominar estes fundamentos elimina a maior parte dos problemas de conectividade e devolve tempo para o que realmente importa: entregar software.

Feito!

segunda-feira, 7 de julho de 2025

Entenda o conceito que está revolucionando o desenvolvimento de software

A área de tecnologia está em constante transformação, e um dos conceitos mais importantes da atualidade é o DevOps. Mais do que uma simples combinação entre "Desenvolvimento" e "Operações", o DevOps representa uma mudança cultural e técnica que tem ajudado empresas a entregar software de forma mais rápida, segura e eficiente.

No presente artigo, vamos explorar o que é DevOps, por que ele surgiu, quais são seus principais benefícios e como essa prática tem mudado a forma como times de tecnologia trabalham em conjunto.

Por que surgiu o DevOps?

Durante muito tempo, as áreas de desenvolvimento e infraestrutura (operações) trabalhavam de forma isolada. O time de desenvolvimento era responsável por escrever o código, enquanto o time de operações cuidava da infraestrutura e da publicação do sistema. Essa separação gerava atrasos, conflitos e até falhas em produção, principalmente quando havia mudanças frequentes.

Foi nesse contexto que surgiu o DevOps, como uma resposta à necessidade de melhorar a comunicação entre os times, automatizar processos e garantir entregas mais confiáveis. O termo começou a ganhar força por volta de 2009, a partir de comunidades de tecnologia que buscavam uma cultura mais colaborativa.

O que é DevOps, afinal?

DevOps é um conjunto de práticas, ferramentas e uma cultura organizacional que visa integrar os times de desenvolvimento (Dev) e operações (Ops), promovendo colaboração contínua ao longo de todo o ciclo de vida do software, desde o planejamento e desenvolvimento até a entrega e manutenção em produção.

O foco do DevOps é criar um ambiente onde as equipes possam trabalhar de forma conjunta, entregando valor de forma contínua, ágil e com qualidade.

Quais são os pilares do DevOps?

Para funcionar bem, o DevOps se apoia em alguns pilares fundamentais:

  • Colaboração:
  • Times multidisciplinares que trabalham juntos com objetivos em comum.

  • Automação:
  • Processos como testes, integração contínua, entrega contínua e monitoramento são automatizados.

  • Integração Contínua (CI):
  • Cada alteração de código é integrada ao projeto automaticamente, garantindo testes e feedback rápidos.

  • Entrega Contínua (CD):
  • Novas versões do sistema são entregues com frequência e com menos riscos.

  • Monitoramento e feedback:
  • O sistema é monitorado em tempo real e os times utilizam os dados para melhorar continuamente.

Benefícios do DevOps

Adotar DevOps traz uma série de benefícios para empresas e profissionais de tecnologia. Entre os principais, destacam-se:

  • Entregas mais rápidas e frequentes de software;
  • Maior confiabilidade nas implantações em produção;
  • Redução de erros e falhas;
  • Melhoria na colaboração entre áreas;
  • Maior satisfação do cliente.

Além disso, o DevOps permite uma melhor adaptação a mudanças, essencial em um mercado tão dinâmico como o de tecnologia.

DevOps é só ferramenta?

Embora existam muitas ferramentas que suportam práticas DevOps (como Jenkins, Docker, Kubernetes, GitLab CI/CD, entre outras), é importante entender que DevOps é, antes de tudo, uma mudança de cultura.

Sem colaboração entre os times e comprometimento com a melhoria contínua, nenhuma ferramenta será suficiente para garantir o sucesso da adoção de DevOps.

Considerações finais:

DevOps é uma abordagem que vem transformando a maneira como desenvolvemos e entregamos software. Ao unir desenvolvimento e operações com foco em automação, colaboração e melhoria contínua, as empresas conseguem ser mais ágeis, resilientes e inovadoras.

Se você trabalha com tecnologia, seja como desenvolvedor, administrador de sistemas, QA ou gestor, entender e aplicar os princípios de DevOps pode ser um diferencial importante na sua carreira e nos resultados da sua equipe.

Feito!

terça-feira, 22 de abril de 2025

Guia completo de deploy com Docker e Docker Compose

Como containerizar aplicações e orquestrar múltiplos serviços de forma simples e escalável

O que é Docker?

Docker é uma plataforma que permite empacotar sua aplicação e todas as suas dependências em containers. Com ele, conseguimos criar ambientes portáveis, previsíveis e fáceis de replicar em qualquer lugar, seja na máquina do dev, no servidor ou na nuvem.

Pensa no container como uma mini máquina virtual superleve e isolada, rodando apenas o necessário para sua aplicação funcionar.

Por que usar Docker?

Elimina o "na minha máquina funciona"

Padroniza ambientes de desenvolvimento, staging e produção

Facilita o CI/CD

Escala horizontalmente de forma controlada

Dockerizando sua aplicação

Vamos usar um exemplo básico de uma API Node.js + Express.

Pode usar a sua API que você desenvolveu em Node.js com Express

  1. Estrutura de diretórios
  2. /meu-projeto
    │
    ├── Dockerfile
    ├── docker-compose.yml
    ├── package.json
    └── src/
        └── index.js
    
  3. Dockerfile
  4. 
    # Usa uma imagem base
    FROM node:18-alpine
    
    # Cria um diretório de trabalho
    WORKDIR /app
    
    # Copia os arquivos
    COPY package*.json ./
    RUN npm install
    
    COPY . .
    
    # Expõe a porta da aplicação
    EXPOSE 3000
    
    # Comando para iniciar o app
    CMD ["node", "src/index.js"]
    
    
  5. Docker Compose com MongoDB
  6. 
    version: '3.8'
    services:
      app:
        build: .
        ports:
          - "3000:3000"
        volumes:
          - .:/app
        depends_on:
          - mongo
        environment:
          - MONGO_URL=mongodb://mongo:27017/meubanco
    
      mongo:
        image: mongo:6
        container_name: mongodb
        ports:
          - "27017:27017"
        volumes:
          - mongo-data:/data/db
      
      mongo-express:
        image: mongo-express
        container_name: mongo-express
        ports:
          - "8081:8081"
        environment:
          ME_CONFIG_MONGODB_SERVER: mongo
          ME_CONFIG_BASICAUTH_USERNAME: admin
          ME_CONFIG_BASICAUTH_PASSWORD: admin
    
    volumes:
      mongo-data:
    
    
  7. Subindo os serviços
  8. No terminal, dentro do diretório do projeto:

    docker-compose up -d --build

Pronto! Sua API e o Mongo estão executando em containers separados, mas se comunicando em rede.

Testando

Acesse: http://localhost:3000 no Postman ou Insonmia para testar os endpoints da sua API REST com Node.js e Express

e http://localhost:8081 para acessar o Mongo Express, que é o cliente do MongoDB

Dicas de produção

  • Crie um .dockerignore para ignorar node_modules, .git, etc.
  • Use variáveis de ambiente no docker-compose.yml com arquivos .env
  • Utilize healthchecks para garantir que os serviços estejam realmente prontos
  • Adicione nginx como proxy reverso e certbot para HTTPS
  • Faça uso de volumes persistentes para bancos de dados
  • Considere usar Docker Swarm ou Kubernetes em ambientes que exigem alta escalabilidade
.dockerignore
node_modules
npm-debug.log
.git
.env
Dockerfile*
docker-compose*
Dockerfile (Produção)

# Etapa de build
FROM node:18-alpine as builder

WORKDIR /app
COPY package*.json ./
RUN npm install --production

COPY . .

# Etapa final
FROM node:18-alpine

WORKDIR /app

# Copia apenas o que foi instalado/built na etapa anterior
COPY --from=builder /app /app

# Define variáveis de ambiente
ENV NODE_ENV=production

EXPOSE 3000
CMD ["node", "src/index.js"]

docker-compose.prod.yml

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "80:3000"
    env_file:
      - .env
    depends_on:
      - mongo
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: always
    volumes:
      - .:/app
      - /app/node_modules # evita conflito com o host

  mongo:
    image: mongo:6
    container_name: mongodb
    restart: always
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
    healthcheck:
      test: ["CMD", "mongosh", "--eval", 
             "db.adminCommand('ping')"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  mongo-data:

.env
MONGO_URL=mongodb://mongo:27017/meubanco
PORT=3000
NODE_ENV=production

Considerações finais

Docker e Docker Compose transformaram a forma como lidamos com deploys. Com uma configuração simples, conseguimos orquestrar múltiplos serviços, versionar ambientes, simular produção localmente e escalar nossas aplicações com segurança.

Quer começar? Pegue um projeto seu e faça o primeiro Dockerfile. Depois adicione um banco com docker-compose. Em pouco tempo, isso torna-se parte do seu workflow natural.

Feito!

sexta-feira, 20 de dezembro de 2024

Ambiente Docker online e gratuito para testes de containers

O Docker revolucionou a forma como criamos, distribuímos e executamos aplicações. Mas nem sempre temos um ambiente configurado para experimentar ou aprender sobre essa tecnologia poderosa. É aqui que o Play With Docker brilha. Essa plataforma gratuita oferece um ambiente pronto para explorar o Docker, diretamente no navegador.

O Play With Docker é uma plataforma interativa que permite:

  • Criar instâncias temporárias para executar containers.
  • Praticar comandos do Docker em um terminal baseado em Linux.
  • Testar configurações de rede entre containers.
  • Experimentar tutoriais e conceitos avançados, como Docker Compose, Swarm e volumes.
  • Tudo isso sem precisar instalar nada no seu computador!

Como começar

Ter uma conta no Docker Hub para logar na plataforma Play With Docker

Caso ainda não tiver uma conta no Docker Hub, crie uma gratuitamente

Após logar na plataforma Play With Docker, crie sessões, inicie uma nova sessão e comece a explorar. Você terá até 4 horas por sessão.

Pode adicionar nós, teste múltiplos containers ou crie clusters usando até 5 nós.

Principais funcionalidades

  • Ambiente seguro e temporário:
  • Ideal para testes rápidos.

  • Interface simples:
  • Terminal Linux no navegador. Também pode conectar no SSH da plataforma, basta copiar o endereço no campo SSH e colar no seu terminal e pronto para executar containers usando o terminal do seu computador conectado na plataforma.

Casos de Uso

  • Aprendizado inicial:
  • Execute comandos básicos do Docker sem se preocupar com instalação.

  • Testes de configuração:
  • Simule redes, volumes e clusters.

  • Demonstrações rápidas:
  • Ideal para workshops e apresentações.

Limitações

Sessões são temporárias (máximo de 4 horas).

Recursos limitados em comparação com um ambiente local ou servidor dedicado.

Considerações finais

O Play With Docker é uma excelente ferramenta para quem quer aprender Docker de maneira prática e acessível. Seja para explorar novos conceitos, realizar testes rápidos ou ensinar colegas, ele elimina barreiras iniciais e torna o aprendizado muito mais fluido.

Referências

https://labs.play-with-docker.com/

Feito!

terça-feira, 22 de outubro de 2024

Aprenda SQL do zero ao avançado

SQL (Structured Query Language) é uma linguagem de programação utilizada principalmente para interagir com bancos de dados relacionais. É fundamental entender o conceito de Sistema Gerenciador de Banco de Dados (SGBD) antes de mergulhar na aprendizagem de SQL.

Conceito de SGBD

Um Sistema Gerenciador de Banco de Dados (SGBD) é um software que permite criar, organizar, armazenar, recuperar e manipular dados em um banco de dados. Os principais componentes de um SGBD incluem:

  • Motor de banco de dados
  • Linguagem de consulta
  • Interface de usuário
  • Sistema operacional

Exemplo prático: MySQL

MySQL é um dos SGBDs mais populares e amplamente utilizado. Ele oferece uma interface de linha de comando e suporta várias linguagens de programação.

MariaDB

O MariaDB é um SGBD multiplataforma lançado em 2009, fork do MySQL. Algumas de suas vantagens incluem:

  • Baseado no MySQL
  • Licença GNU GPL
  • Multiplataforma

PostgreSQL

O PostgreSQL é outro SGBD muito popular e avançado. Algumas de suas principais características incluem:

  • Open source, sob a licença BSD e multiplataforma
  • Suporta diferentes tipos de dados
  • Meios de consulta mais complexos
  • Chaves estrangeiras e outros recursos avançados
  • Escalável para projetos de maior escala

Oracle Database

O Oracle Database é um dos SGBDs mais utilizados em aplicações corporativas:

  • Desenvolvido pela Oracle Corporation
  • Multiplataforma
  • Licença comercial
  • Suporta desde demandas simples até complexas
  • Excelente para aplicações corporativas

Microsoft SQL Server

O Microsoft SQL Server é desenvolvido pela Microsoft:

  • Disponível para Windows e Linux
  • Possui licença proprietária
  • Atende desde demandas simples até complexas
  • Robustos recursos de segurança
  • Meios de criptografia avançados

Criação do container MySQL

É necessário ter o Docker instalado no SO (Windows, Linux). Caso estja no Windows, habilite o recurso WSL2 e na loja Microsoft, pesquise Ubuntu, após a instalação do Ubuntu no WSL2, abre o terminal do Linux (Ubuntu) e segue os procedimentos abaixo dos itens 1 até 4, caso já estiver com Docker, continue no item 5.

  1. Atualização do sistema
  2. sudo apt update && sudo apt upgrade -y
  3. Instalação do Docker
  4. sudo apt install docker.io -y
  5. Inicialização do serviço Docker
  6. sudo systemctl start docker
  7. Habilitar a inicializaçao do serviço Docker no boot do sistema
  8. sudo systemctl enable docker
  9. Criar o conteiner MySQL
  10.   sudo docker run -d \
      --name projeto1_mysql \
      -p 3306:3306 \
      -e MYSQL_ROOT_PASSWORD=secret \
      -e MYSQL_DATABASE=projeto1 \
      -v projeto1_data:/var/lib/mysql \
      mysql:8
      
      

Conectando ao banco de dados

Utilizando um cliente MySQL (DBeaver), conecte no banco de dados com as devidas credenciais (usuário e senha) definido na instalação e host/porta.

Host: 127.0.0.1

Port: 3306

Username: root

Password: secret

Database: projeto1

Criação das tabelas usuários e pedido

Utilizando o banco de dados projeto1, antes de criar as tabelas, precisa selecionar qual banco de dados que serão criadas. Para isso, execute:

USE projeto1;

CREATE TABLE usuarios (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(255),
    email VARCHAR(255) UNIQUE,
    data_nascimento DATE
);

CREATE TABLE pedidos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    usuario_id INT,
    produto VARCHAR(255),
    preco DECIMAL(10,2),
    quantidade INT,
    data_pedido DATE,
    FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);

A tabela pedidos tem as seguintes características:
  1. O campo id é o identificador principal da tabela, gerado automaticamente pelo MySQL.
  2. usuario_id é um campo que relaciona os pedidos aos usuários específicos.
  3. produto armazena o nome do produto comprado.
  4. preco armazena o preço do produto com duas casas decimais.
  5. quantidade indica quantos itens foram comprados.
  6. data_pedido registra a data em que o pedido foi feito.
  7. Adicionamos uma chave estrangeira (FOREIGN KEY) para estabelecer uma relação entre pedidos e usuarios.

Esta estrutura permite que você mantenha dados sobre os usuários e seus respectivos pedidos, facilitando análises e consultas mais complexas posteriormente.

Fundamentos básicos de SQL

Agora, vamos explorar alguns conceitos básicos de SQL:

SELECT

O comando SELECT é usado para recuperar dados de uma ou mais tabelas.

Exemplo prático:

SELECT * FROM usuarios;

Este comando retorna todos os registros da tabela usuarios.

INSERT

O comando INSERT é utilizado para inserir novos registros em uma tabela.

Exemplo prático:

INSERT INTO usuarios (nome, email, data_nascimento) VALUES ('Bjorn Cyril', 'bjorn.cyril@hotmail.com', '1990-11-07');

INSERT INTO pedidos (id, usuario_id, produto, preco, quantidade, data_pedido) VALUES (1, 1, 'Camiseta Azul', 29.99, 2, '2024-10-20');

UPDATE

O comando UPDATE é usado para modificar dados existentes em uma tabela.

WARNING: Sempre utilize o WHERE no comando UPDATE

Exemplo prático:

UPDATE usuarios SET email = 'bjorn.cyril@gmail.com' WHERE id = 1;

DELETE

O comando DELETE é utilizado para remover registros de uma tabela.

WARNING: Sempre utilize o WHERE no comando DELETE

Exemplo prático:

DELETE FROM usuarios WHERE id = 1;

Consultas Avançadas

Vamos explorar algumas técnicas mais avançadas de SQL:

JOIN

O JOIN é usado para combinar dados de duas ou mais tabelas relacionadas.

Exemplo prático:

SELECT u.nome, p.preco FROM usuarios u JOIN pedidos p ON u.id = p.usuario_id;

Este exemplo mostra como combinar dados dos usuários e seus pedidos.

GROUP BY

O GROUP BY agrupa resultados por valores específicos.

Exemplo prático:

SELECT COUNT(*) AS quantidade_pedidos, AVG(preco) AS media_preco FROM pedidos GROUP BY usuario_id;

Este comando retorna a quantidade de pedidos e a média de preço por usuário.

Conceitos avançados

Agora vamos mergulhar em alguns conceitos mais avançados de SQL:

Subquery

Uma subquery é uma consulta dentro de outra consulta.

Exemplo prático:


SELECT *
FROM usuarios
WHERE id IN (
    SELECT usuario_id
    FROM pedidos
    WHERE preco > 100
);

Esta consulta seleciona usuários que fizeram pedidos com valor superior a 100.

UNION

O UNION combina os resultados de duas ou mais consultas.

Exemplo prático:


SELECT nome, email
FROM usuarios
UNION
SELECT nome, email
FROM clientes;

Este comando combina os resultados das tabelas usuarios e clientes.

A tabela clientes não foi criada, antes de executar, crie a tabela clientes, com base dos exemplos das tabela pedidos.

Comandos úteis do Docker

Para parar o container

sudo docker stop projeto1_mysql

Para iniciar o container

sudo docker start projeto1_mysql

Para remover o container

sudo docker rm projeto1_mysql

Para remover o volume

sudo docker volume rm projeto1_data

Considerações finais

SQL é uma linguagem poderosa e versátil que forma a base de muitos sistemas de banco de dados modernos. Compreender esses conceitos básicos e avançados é fundamental para qualquer desenvolvedor ou analista de dados.

Pratique regularmente e explore diferentes bancos de dados para melhorar suas habilidades. Lembre-se de que a prática é a chave para dominar SQL efetivamente.

Feito!

sexta-feira, 12 de abril de 2024

Por que o Docker é a escolha superior do que XAMPP e Laragon no desenvolvimento PHP?

O mundo do desenvolvimento web está em constante evolução, e com ele, surgem novas ferramentas e tecnologias destinadas a tornar o processo de desenvolvimento mais eficiente e produtivo. No contexto do ambiente de desenvolvimento PHP, o Docker emerge como uma opção superior em comparação ao XAMPP e Laragon, oferecendo uma série de vantagens que não podem ser ignoradas.

  1. Isolamento e consistência do ambiente:
  2. Uma das maiores vantagens do Docker é sua capacidade de fornecer ambientes de desenvolvimento isolados e consistentes. Enquanto o XAMPP e o Laragon dependem de instalações diretas no sistema operacional do usuário, o Docker empacota aplicativos e suas dependências em contêineres leves e independentes. Isso significa que cada projeto PHP pode ter seu próprio ambiente isolado, com versões específicas de PHP, bibliotecas e extensões, garantindo consistência entre ambientes de desenvolvimento, testes e produção.

  3. Gerenciamento de dependências simplificado:
  4. Com o Docker, o gerenciamento de dependências torna-se muito mais simples e flexível. Em vez de lidar com instalações manuais de bibliotecas e extensões, os desenvolvedores podem especificar as dependências necessárias em um arquivo de configuração (como o Dockerfile) e construir um contêiner personalizado com todas as dependências necessárias. Isso facilita a reprodução do ambiente de desenvolvimento em diferentes máquinas e elimina as dores de cabeça associadas à resolução de dependências.

  5. Escalabilidade e portabilidade:
  6. Outra vantagem do Docker é sua escalabilidade e portabilidade. Os contêineres Docker podem ser facilmente escalados horizontalmente para lidar com aumentos de carga de tráfego, e podem ser implantados em qualquer lugar que suporte Docker, seja em servidores locais, na nuvem ou em ambientes de desenvolvimento compartilhados. Isso proporciona uma flexibilidade sem precedentes para desenvolvedores PHP que desejam criar, testar e implantar aplicativos em uma variedade de ambientes.

  7. Integração com ferramentas de DevOps:
  8. O Docker se integra perfeitamente com ferramentas populares de DevOps, como Kubernetes, Jenkins, GitHub GitHub Actions, Bitbucket Pipelines e GitLab CI/CD. Isso permite a automação de processos de construção, teste e implantação, tornando o ciclo de vida de desenvolvimento mais eficiente e previsível. Além disso, a capacidade de empacotar aplicativos em contêineres simplifica a implantação e o dimensionamento em ambientes de produção, melhorando a confiabilidade e a disponibilidade dos aplicativos PHP.

Considerações finais:

Embora o XAMPP e o Laragon tenham sido escolhas populares para desenvolvedores PHP no passado, o Docker emergiu como a escolha superior em termos de eficiência, flexibilidade e escalabilidade. Ao fornecer ambientes de desenvolvimento isolados, gerenciamento simplificado de dependências, escalabilidade e portabilidade, e integração com ferramentas de DevOps, o Docker capacita os desenvolvedores PHP a criar aplicativos web de forma mais rápida, confiável e escalável. Portanto, para aqueles que buscam o melhor em ambiente de desenvolvimento PHP, o Docker se destaca como a solução ideal.

Feito!

terça-feira, 12 de dezembro de 2023

Garanta a segurança de suas imagens de contêiner: Como assinar e proteger seus deployments com Cosign

A assinatura de imagens de contêiner com Cosign é uma prática importante para garantir a integridade e a autenticidade das imagens utilizadas em ambientes de contêiner. Cosign é uma ferramenta que permite assinar e verificar imagens, tornando-as mais seguras.

Por que é importante assinar as imagens de contêiner?

A assinatura de imagens de contêiner com Cosign é importante por várias razões:

Integridade da imagem: Ao assinar uma imagem, você pode verificar se ela não foi alterada após a assinatura. Isso ajuda a garantir que a imagem que está sendo executada é a mesma que foi originalmente criada e assinada.

Autenticidade: A assinatura fornece uma maneira de garantir a origem da imagem. Você pode ter certeza de que a imagem foi criada pela entidade que possui a chave de assinatura.

Segurança: A utilização de imagens de contêiner assinadas ajuda a evitar a execução de imagens maliciosas ou não confiáveis, o que pode ser crucial em ambientes de contêiner.

Conformidade: Em ambientes onde a conformidade é importante, a assinatura de imagens pode ser um requisito para cumprir regulamentos de segurança e governança.

Segue os procedimentos para o Cosign, gerar o par de chaves pública e privada para assinatura, assinar a imagem do container.

curl -O -L "https://github.com/sigstore/cosign/releases/latest/download/cosign-linux-amd64"

mv cosign-linux-amd64 /usr/local/bin/cosign

chmod +x /usr/local/bin/cosign

cosign generate-key-pair

Crie um Dockerfile para sua aplicação

Com o Dockerfile criado, pode fazer o build da imagem, conforme segue:

docker build -t usuario/nome-imagemm:1.0 .

Verifique a imagem buildada

docker images | grep nome-imagem

Publicar a imagem no Docker Hub

docker push usuario/nome-imagem:1.0

Assinar a imagem com a chave privada

cosign sign -key cosign.key usuario/nome-imagem:1.0

Verificar a imagem com a chave pública

cosign verify -key cosign.pub usuario/nome-imagem:1.0

Considerações finais

Assinar imagens de contêiner com ferramentas como o Cosign é uma prática crucial para garantir a integridade, autenticidade e segurança das imagens que você utiliza. Especialmente em ambientes de contêiner, onde a portabilidade e a confiabilidade são essenciais, a assinatura de imagens desempenha um papel fundamental na prevenção de ameaças e na garantia de que você está executando apenas o código que deseja.

Você está disposto a assumir o controle da segurança das suas imagens de contêiner a partir de hoje?

Assinar suas imagens de contêiner não é apenas uma medida de segurança, mas também uma responsabilidade para qualquer pessoa ou organização que trabalha com contêineres. É uma camada adicional de proteção que pode evitar potenciais problemas de segurança e garantir que você esteja utilizando apenas imagens confiáveis.

Portanto, não deixe a segurança de suas imagens de contêiner ao acaso. Considere seriamente a assinatura de suas imagens a partir de hoje para fortalecer a integridade e a autenticidade de seus aplicativos em ambientes de contêiner. Afinal, a segurança é um compromisso contínuo e a prevenção é sempre mais eficaz do que a correção.

Feito!

quarta-feira, 16 de agosto de 2023

Entendendo o funcionando do Docker por debaixo dos panos

Por baixo dos panos, o Docker é construído sobre várias tecnologias do kernel do Linux, incluindo namespaces, cgroups, UnionFS e outras ferramentas para permitir o isolamento e gerenciamento eficiente de containers.

Namespaces:

Os namespaces permitem isolar recursos do sistema, como processos, rede, sistema de arquivos, entre outros. Cada container Docker é criado em um conjunto de namespaces, o que garante que os processos em um container não possam ver nem interagir com processos fora dele.

Os principais namespaces usados pelo Docker são: PID (para isolar processos), NET (para isolar a rede), MNT (para isolar o sistema de arquivos), UTS (para isolar o hostname), IPC (para isolar a comunicação interprocesso) e USER (para isolar os IDs de usuário).

Cgroups (Control Groups):

Os cgroups permitem limitar, contabilizar e isolar o uso de recursos, como CPU, memória, E/S de disco e rede, para grupos de processos. O Docker usa cgroups para garantir que os containers tenham uma cota de recursos definida, evitando que um container consuma todos os recursos do sistema.

Com cgroups, o Docker pode controlar e distribuir recursos entre diferentes containers de forma justa e previsível.

UnionFS:

O UnionFS é usado para criar um sistema de arquivos em camadas dentro de um container Docker. Ele permite que diferentes camadas (imagens) sejam empilhadas para formar o sistema de arquivos completo do container.

Cada camada representa alterações ou adições ao sistema de arquivos. Isso permite que múltiplos containers compartilhem camadas de imagem idênticas, economizando espaço em disco e facilitando o gerenciamento de imagens.

Docker Daemon e Cliente:

O Docker funciona em um modelo cliente-servidor, onde o Docker Daemon é o servidor e o Docker Cliente é a interface pela qual os usuários interagem com o Docker.

O Docker Daemon é responsável por gerenciar os containers, imagens, volumes e redes. Ele é responsável por criar, iniciar, parar e destruir containers, bem como gerenciar o ciclo de vida das imagens.

O Docker Cliente é uma CLI (Interface de Linha de Comando) que permite aos usuários enviar comandos para o Docker Daemon. O Cliente envia as solicitações para o Daemon, que as processa e executa as ações necessárias.

Docker Image e Container:

Uma Docker Image é uma estrutura de arquivos somente leitura usada para criar containers. Uma imagem contém o sistema de arquivos raiz e as configurações necessárias para executar um aplicativo. Ela é composta por uma ou mais camadas de UnionFS, onde cada camada é uma modificação ou adição em relação à camada anterior.

Um Docker Container é uma instância em execução de uma imagem. É um ambiente isolado que contém um sistema de arquivos que deriva da imagem, juntamente com um conjunto de processos que estão sendo executados.

Quando você executa um container Docker, o Docker Daemon utiliza as tecnologias do kernel mencionadas (namespaces, cgroups e UnionFS) para criar o ambiente isolado para o container. A partir da imagem base, ele cria uma camada de sistema de arquivos (layer) somente leitura e, em seguida, adiciona uma camada somente leitura para os arquivos do sistema de arquivos do container. A partir daí, ele cria uma camada de escrita para quaisquer alterações feitas no sistema de arquivos durante a execução do container.

Esse modelo de camadas permite que os containers sejam leves e eficientes, compartilhando recursos sempre que possível e tornando o processo de criação e distribuição de containers mais rápido e fácil.

Criando um container sem o Docker, utilizando apenas os recursos de namespaces, cgroups e o utilitário chroot.

Após entendermos a teoria do funcionamento do Docker, agora vamos criar um container sem Docker, utilizando os recursos de namespaces, cgroups e o chroot.

No GNU/Linux Debian ou Ubuntu, segue:

sudo apt update

sudo apt install debootstrap -y

mkdir /mnt/debian

sudo debootstrap stable /mnt/debian http://deb.debian.org/debian

Para visualizar os arquivos da imagem Debian que foi criado pelo pacote debootstrap.

ls -la /mnt/debian

chroot /mnt/debian /bin/bash

A partir desse momento está no outro SO que foi instalado com a imagem do Debian com debootstrap

cat /etc/debian_version

cat /etc/issue

exit

Agora vamos fazer o isolamento de processos da imagem minialista do Debian criada com debootstrap com o comando seguinte:

unshare --mount --uts --ipc --net --pid --user --map-root-user --fork --uts --ipc chroot /mnt/debian /bin/bash

mount -t proc proc /proc

ps -ef

Outra aba do terminal

ps aux | grep bash

Identificar o PID do bash

sudo chroot debian bash

apt update

apt install stress

exit

unshare --mount --uts --ipc --net --pid --user --map-root-user --fork --uts --ipc chroot /mnt/debian /bin/bash

mount -t proc proc /proc

mount -t sysfs sys /sys

mount -t tmpfs tmp /tmp

ps -ef

Na máquina física

sudo apt install cgroup-tools

sudo cgcreate -g memory,cpu,blkio,freezer,devices:/nome-grupo

cat /sys/fs/cgroup/memory/nome-grupo

cgclassify -g memory,cpu,blkio,freezer,devices:nome-grupo PID(bash-criado-pelo-unshare)

cat /sys/fs/cgroup/cpu/nome-grupo/tasks

sudo cgset -r memory.limit_in_bytes=128M nome-grupo

sudo cgget -r memory.stat nome-grupo

cat /sys/fs/cgroup/memory/nome-grupo/memory.limit_in_bytes

sudo cgset -r cpu.cfs_periodo_us=100000 -r cpu.cfs_quota_us=$[ 10000 * 32] nome-grupo

stress --cpu 1 --vm-bytes 120M --VM 1

Com esses procedimentos executados você pode observar o funcionamento por debaixos dos panos do Docker, a criação de um container sem Docker, por meio da imagem minialista do Debian e o isolamento de processos com namespaces, cgroups, chroot, unshare e teste de stress do container puro criado.

Feito!

domingo, 16 de outubro de 2022

Configurando e iniciando o projeto Flask no ambiente Docker

Flask é um micro-framework, lançado em 2010 e desenvolvido por Armin Ronatcher, seu foco é para pequenas aplicações com requisitos simples, como site básico e para desenvolvimento de API REST em Python.

O objetivo deste post, é explicar os procedimentos de configuração e inicialização de um projeto base em Flask no ambiente Docker.

$ mkdir $HOME/ambiente-flask-docker && cd $HOME/ambiente-flask-docker

Crie o arquivo app.py com o seguinte conteúdo:

app.py


from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello World!"

if __name__ == "__main__":
    app.run(host="0.0.0.0")


Preparando o ambiente Flask no Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

Crie o Dockerfile no diretório python-flask com o seguinte conteúdo

$ cd $HOME/ambiente-flask-docker && mkdir python-flask

Dockerfile


FROM python:3.6.1-alpine
RUN pip install flask
CMD ["python","app.py"]

Configurando o Docker Compose

Crie o arquivo docker-compose.yml no diretório criado anteriormente

docker-compose.yml


version: '3'
services:
   python-flask:
     build: 
      args:
        user: saitam
        uid: 1000
      context: ./python-flask
     container_name: python-flask
     volumes:
       - ./src:/app
     ports:
       - "5000:5000"

$ docker-compose up -d

Abre o browser http://localhost:5000, irá exibir o conteúdo "Hello World!" definido na rota /. Crie outros endpoints para testes, antes de desenvolver a API REST com Flask.

Para acessar o container é $ docker exec -it python-flask bash

Pronto, a partir desse momento já tem o ambiente Flask no Docker para seus projetos.

Referências

https://flask.palletsprojects.com/en/2.2.x/

Feito!

sábado, 15 de outubro de 2022

Configurando e iniciando projeto Angular no ambiente Docker

O objetivo deste post, é explicar os procedimentos de configuração e inicialização do projeto Angular no ambiente Docker.

Preparando o ambiente Angular no Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir $HOME/ambiente-angular-docker && cd $HOME/ambiente-angular-docker

$ docker run --rm --volume "/home/reginaldo/ambiente-angular-docker:/usr/node/app" --workdir "/usr/node/app" --publish 4200:4200 -it node:18 bash

O comando acima, irá conectar ao conteiner node, de modo similar como estiver conectado a outro computador via SSH.

Na primeira vez que executar, o Docker irá fazer o download da imagem node:18 e pode levar alguns minutos.

Explicando os parâmetros informados:

--volume "/home/reginaldo/ambiente-angular-docker:/usr/node/app" Cria o link entre o diretório do HOST (/home/reginaldo/ambiente-angular-docker) com o diretório do CONTAINER (/usr/node/app).

--WORKDIR "/usr/node/app" Diretório inicial no momento que o container foi inicializado.

--publish 4200:4200 Cria um link entre a porta 4200 do HOST com a porta 4200 do CONTAINER

--it Cria um link entre o terminal do container com o terminal do HOST

--rm Remove antigos containers (muito útil depois da primeira execução)

Criando o primeiro projeto Angular

Estando conectado no container node com o comando que executou anteriormente, conforme explicado.

Primeiro, vamos instalar o Angular via NPM

npm install -g @angular/cli

Agora vamos criar o projeto Angular

ng new .

O . indica que irá criar o nome do projeto com mesmo nome do diretório criado.

Informe as configurações desejadas para seu projeto e só aguardar o projeto ser configurado.

Pronto, o primeiro aplicativo Angular foi criado.

É importante salientar que ambiente com Docker é volátil, quando não criado o volume que mapeia o diretório entre HOST e CONTAINER, conforme foi criado no comando é adicionado o volume.

No diretório volume do HOST, observe o Owner, provavelmente irá precisar alterar para o seu usuário.

$ sudo chown -R $USER $HOME/ambiente-angular-docker

Além do arquivo .gitignore é recomendado criar o arquivo .dockerignore e adicionar o node_modules

Executando o projeto Angular no Docker

No diretório do volume, adaptando o nome do seu usuário, execute:

$ docker run --rm --volume "/home/reginaldo/ambiente-angular-docker:/usr/node/app" --workdir "/usr/node/app" --publish 4200:4200 -it node:18 bash

Estando conectado no container node, execute o comando:

ng serve

Abre o browser http://localhost:4200

Configurando o ambiente Angular no Docker Compose

Para não precisar executar o comando Docker Run toda hora, pode simplificar e organizar com o Docker Compose

Pode criar o arquivo docker-compose.yml no diretório de sua preferência

docker-compose.yml


version: '3'

services:
  node:
    image: node:18
    container_name: ambiente-angular
    args:
      user: saitam
      uid: 1000
    ports:
      - '4200:4200'
    volumes:
      - ./src:/usr/node/app
    working_dir: /usr/node/app
    command: 'ng serve'

$ docker-compose up

OU

$ docker-compose up -d

O primeiro comando o log fica aberto em tempo de execução. O segundo é executado em background. Eu prefiro executar o segundo, quando preciso verificar o log, executo docker ps

E para acessar o container é $ docker exec -it <CONTAINERID> bash

Pronto, a partir desse momento já tem o ambiente Angular no Docker para seus projetos.

Feito!

sexta-feira, 14 de outubro de 2022

Configurando e iniciando projeto Vue.js no ambiente Docker

O objetivo deste post, é explicar os procedimentos de configuração e inicialização do projeto Vuejs no ambiente Docker.

Preparando o ambiente Vue.js no Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir $HOME/ambiente-vuejs-docker && cd $HOME/ambiente-vuejs-docker

$ docker run --rm --volume "/home/reginaldo/ambiente-vuejs-docker:/usr/node/app" --workdir "/usr/node/app" --publish 8080:8080 -it node:18 bash

O comando acima, irá conectar ao conteiner node, de modo similar como estiver conectado a outro computador via SSH.

Na primeira vez que executar, o Docker irá fazer o download da imagem node:18 e pode levar alguns minutos.

Explicando os parâmetros informados:

--volume "/home/reginaldo/ambiente-vuejs-docker:/usr/node/app" Cria o link entre o diretório do HOST (/home/reginaldo/ambiente-vuejs-docker) com o diretório do CONTAINER (/usr/node/app).

--WORKDIR "/usr/node/app" Diretório inicial no momento que o container foi inicializado.

--publish 8080:8080 Cria um link entre a porta 8080 do HOST com a porta 8080 do CONTAINER

--it Cria um link entre o terminal do container com o terminal do HOST

--rm Remove antigos containers (muito útil depois da primeira execução)

Criando o primeiro projeto Vue.js

Estando conectado no container node com o comando que executou anteriormente, conforme explicado.

Primeiro, vamos instalar o Vue via NPM

npm install -g @vue/cli

Agora vamos criar o projeto Vue.js

vue create .

O . indica que irá criar o nome do projeto com mesmo nome do diretório criado.

Informe as configurações desejadas para seu projeto e só aguardar o projeto ser configurado.

Pronto, o primeiro aplicativo Angular foi criado.

É importante salientar que ambiente com Docker é volátil, quando não criado o volume que mapeia o diretório entre HOST e CONTAINER, conforme foi criado no comando é adicionado o volume.

No diretório volume do HOST, observe o Owner, provavelmente irá precisar alterar para o seu usuário.

$ sudo chown -R $USER $HOME/ambiente-vuejs-docker

Além do arquivo .gitignore é recomendado criar o arquivo .dockerignore e adicionar o node_modules

Executando o projeto Vue.js no Docker

No diretório do volume, adaptando o nome do seu usuário, execute:

$ docker run --rm --volume "/home/reginaldo/ambiente-vuejs-docker:/usr/node/app" --workdir "/usr/node/app" --publish 8080:8080 -it node:18 bash

Estando conectado no container node, execute o comando:

npm run serve

Abre o browser http://localhost:8080

Configurando o ambiente Vue.js no Docker Compose

Para não precisar executar o comando Docker Run toda hora, pode simplificar e organizar com o Docker Compose.

Pode criar o arquivo docker-compose.yml no diretório de sua preferência

docker-compose.yml


version: '3'

services:
  node:
    image: node:18
    container_name: ambiente-vuejs
    args:
      user: saitam
      uid: 1000
    ports:
      - '8080:8080'
    volumes:
      - ./src:/usr/node/app
    working_dir: /usr/node/app
    command: 'npm run serve'

$ docker-compose up

OU

$ docker-compose up -d

O primeiro comando o log fica aberto em tempo de execução. O segundo é executado em background. Eu prefiro executar o segundo, quando preciso verificar o log, executo docker ps.

E para acessar o container é $ docker exec -it <CONTAINERID> bash

Pronto, a partir desse momento já tem o ambiente Vue.js no Docker para seus projetos.

Feito!

terça-feira, 11 de outubro de 2022

Configurando e iniciando projeto Node.js no ambiente Docker

O objetivo deste post, é explicar os procedimentos de configuração e inicialização do projeto Node.js no ambiente Docker.

Preparando o ambiente Node.js no Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir ambiente-nodejs-docker && cd ambiente-nodejs-docker

Cria o arquivo app.js


const http = require('http');

const hostname = '127.0.0.1';
const port = 3001;
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain');
res.end('Hello World');
});

server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});

Além do arquivo .gitignore é recomendado criar o arquivo .dockerignore e adicionar o node_modules.

$ docker run --rm --volume "/home/reginaldo/ambiente-nodejs-docker:/usr/node/app" --workdir "/usr/node/app" -it node:18 bash

Estando conectado no container node, execute:

npm install nodemon -g
/srv/node/app/node_modules/.bin/nodemon app.js

Abra o browser http://localhost:3001 irá exibir na página "Hello World".

Configurando o ambiente Node.js com Docker Compose

Pode criar o arquivo docker-compose.yml no diretório de sua preferência, copie o arquivo app.js que é o servidor web do Node.js no diretório src

docker-compose.yml


version: '3'

services:
  node:
    image: node:18
    container_name: ambiente-node
    args:
      user: saitam
      uid: 1000
    ports:
      - '3001:3001'
    volumes:
      - ./src:/srv/node/app
    working_dir: /srv/node/app
    command: '/srv/node/app/node_modules/.bin/nodemon app.js'

docker-compose up -d

Abra o browser http://localhost:3001

Adicionando o Express

Conecte no container conforme segue:

$ docker exec -it ambiente-node bash

Estando no container ambiente-node, execute:

npm install express --save

Pode substituir o conteúdo no arquivo app.js


const express = require('express');
const app = express();

app.get('/', (req, res) => {
res.send('Hello World! na Home');
});

app.get('/hello', (req, res) => {
res.send('Hello World!');
});

app.listen(3001, 'http://127.0.0.1') {
console.log('app listening on port 3001!');
});

Como foi instalado o Nodemon que faz o watch do arquivo para atualizar, sem precisar reiniciar a execução do node app.js. Teste no browser http://localhost:3001 com as rotas que criou.

Pronto, agora já tem o ambiente de desenvolvimento Node.js no Docker, que pode utilizar em paralelo (Backend no Node.js e Frontend no React) com o ambiente React no Docker .

Feito!

segunda-feira, 10 de outubro de 2022

Configurando e iniciando o projeto React no ambiente Docker

Quem já não teve problema com versões incompatíveis na quebra de compatibilidade devido a atualização que funcionava na versão anterior em comparação com a versão atual?

Para evitar isso, recomendado utilizar o Docker no ambiente de desenvolvimento.

O objetivo deste post, é explicar os procedimentos de configuração e inicialização do projeto React no ambiente Docker.

Preparando o ambiente React no Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir $HOME/ambiente-react-docker && cd $HOME/ambiente-react-docker
$ docker run --rm --volume "/home/reginaldo/ambiente-react-docker:/usr/node/app" --workdir "/usr/node/app" --publish 3000:3000 -it node:18 bash

O comando acima, irá conectar ao conteiner node, de modo similar como estiver conectado a outro computador via SSH.

Na primeira vez que executar, o Docker irá fazer o download da imagem node:18 e pode levar alguns minutos.

Explicando os parâmetros informados:

--volume "/home/reginaldo/ambiente-react-docker:/usr/node/app" Cria o link entre o diretório do HOST (/home/reginaldo/ambiente-react-docker) com o diretório do CONTAINER (/usr/node/app).

--WORKDIR "/usr/node/app" Diretório inicial no momento que o container foi inicializado.

--publish 3000:3000 Cria um link entre a porta 3000 do HOST com a porta 3000 do CONTAINER

--it Cria um link entre o terminal do container com o terminal do HOST

--rm Remove antigos containers (muito útil depois da primeira execução)

Criando o primeiro projeto React

Estando conectado no container node com o comando que executou anteriormente, conforme explicado, execute:

npx create-react-app .

Pronto, o primeiro aplicativo React foi criado.

É importante salientar que ambiente com Docker é volátil, quando não criado o volume que mapeia o diretório entre HOST e CONTAINER, conforme foi criado no comando é adicionado o volume.

No diretório volume do HOST, observe o Owner, provavelmente irá precisar alterar para o seu usuário.

$ sudo chown -R $USER $HOME/ambiente-react-docker

Além do arquivo .gitignore é recomendado criar o arquivo .dockerignore e adicionar o node_modules

Executando o projeto React no Docker

No diretório do volume, adaptando o nome do seu usuário, execute:

$ docker run --rm --volume "/home/reginaldo/ambiente-react-docker:/usr/node/app" --workdir "/usr/node/app" --publish 3000:3000 -it node:18 bash

Estando conectado no container node, execute o comando:

npm start

Abre o browser http://localhost:3000

Configurando o ambiente React com Docker Compose

Para não precisar executar o comando Docker Run toda hora, pode simplificar e organizar com o Docker Compose

Pode criar o arquivo docker-compose.yml no diretório de sua preferência

docker-compose.yml


version: '3'

services:
  node:
    image: node:18
    container_name: ambiente-react
    args:
      user: saitam
      uid: 1000
    ports:
      - '3000:3000'
    volumes:
      - ./src:/usr/node/app
    working_dir: /usr/node/app
    command: 'npm start'

$ docker-compose up OU
$ docker-compose up -d

O primeiro comando o log fica aberto em tempo de execução. O segundo é executado em background. Eu prefiro executar o segundo, quando preciso verificar o log, executo docker ps

E para acessar o container é docker exec -it <CONTAINERID> bash

Pronto, a partir desse momento já tem o ambiente React no Docker para seus projetos

Feito!

sexta-feira, 7 de outubro de 2022

Instalando e Configurando o Jenkins no ambiente Docker

O objetivo deste post, é explicar os procedimentos de instalação e configuração do Jenkins no ambiente Docker.

O que é Jenkins?

Jenkins é uma ferramenta de integração contínua de código aberto para automatizar o deploy do projeto, na execução de testes unitários, testes integrados e o build completo.

Instalação e configuração

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir $HOME/jenkins && cd $HOME~/jenkins

$ curl -sSL https://raw.githubusercontent.com/bitnami/containers/main/bitnami/jenkins/docker-compose.yml > docker-compose.yml

PS: Para utilizar no servidor de produção, é recomendado alterar a variável JENKINS_PASSWORD que é o password administrador do Jenkins.

Altere a porta do HOST também, por outra porta alta que não esteja usando.

$ docker-compose up -d

Aguarde subir o ambiente, após concluir, abre o browser e acesse http://localhost:<PORTA>

O acesso username/password default são: admin/bitname.

Caso tenha alterado por meio das variáveis JENKINS_USERNAME e JENKINS_PASSWORD, respectivamente no arquivo docker-compose.yml, então utilize o que você definiu.

Após o acesso do Jenkins, pode criar os Jobs na ordem de execução para o deploy automatizado do seu projeto com CI/CD (Continuos Integrations/Continuos Delivery).

O que é CI/CD?

CI/CD (Continuous Integration/Continuous Delivery), é um método para entregar aplicações com frequência aos clientes. Para isso, é aplicada a automação nas etapas do desenvolvimento de aplicações.

Exemplos de ferramentas que fazem CI/CD: Jenkins, Bamboo, GitHub Actions, CircleCI.

Utilize a ferramenta CI/CD a sua escolha para o seu projeto. É importante ressaltar que essas ferramentas de CI/CD integram com o Git com as plataformas GitHub, Bitbucket e Gitlab.

Referências

https://www.jenkins.io/doc/

Feito!

segunda-feira, 12 de setembro de 2022

Configurando a sua Netflix com Jellyfin

O que é Jellyfin?

O Jellyfin e um serviço de multimídia permitindo fazer o streaming de seus vídeos e qualquer dispositivo de sua escolha. O Jellyfin, totalmente gratuita, você pode usar seus serviços na maioria dos dispositivos. Além de permitir você assistir os filmes da sua biblioteca, também faz a transcodificação de vídeo para melhor exibição dependendo da velocidade de sua internet, e a resolução do seu dispositivo.

Pode instalar na sua máquina ou no seu servidor.

Recomendo instalar o Jellyfin no ambiente Docker, por ser mais simples e rápido.

Instalação e configuração do Jellyfin no ambiente Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

$ mkdir -p jellyfin && cd jellyfin
$ mkdir -p config cache media media2
$ curl -LO https://raw.githubusercontent.com/rmsaitam/jellyfin-docker/main/docker-compose.yml
$ docker-compose up -d

Aguarde subir o ambiente, após concluir, acesse no browser http://IP:8096 ou https://IP:8920

No primeiro acesso ao Jellyfin, é redirecionado para o cadastro do usuário administrador e assim colocar os filmes, vídeos, músicas, no diretório media do volume que foi criado anteriormente.

Pode criar usuários regulares

Pronto, agora tem um servidor multimídia interno na sua rede.

Referências

https://jellyfin.org/

Feito!

terça-feira, 19 de julho de 2022

Conhecendo o framework Lowdefy

O que é Lowdefy?

Lowdefy é um framework Low-Code para desenvolver aplicações web, paineis administrativo, Dashboards e aplicações CRUD de forma fácil e rápida, através de arquivo YAML.

Instalação e Configuração do Lowdefy no ambiente Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

Dockerfile

$ curl -LO https://raw.githubusercontent.com/lowdefy/lowdefy-example-docker/main/config-in-image/Dockerfile

Criar o arquivo .env com as variáveis LOWDEFY_SERVER_BASE_PATH, LOWDEFY_SERVER_BUILD_DIRECTORY, LOWDEFY_SERVER_PUBLIC_DIRECTORY, LOWDEFY_SERVER_PORT

LOWDEFY_SERVER_BASE_PATH: É um identificado do servidor que foi instalado o Lowdefy. http://IP/<base-path>/<page-id> ao invés do default http://IP/<page-id>

LOWDEFY_SERVER_BUILD_DIRECTORY: É o diretório de configuração do Lowdefy. O default é ./build ou /home/nome/lowdefy/build.

LOWDEFY_SERVER_PUBLIC_DIRECTORY: É o diretório público, onde fica as páginas estática. O default é ./public ou /home/nome/lowdefy/public.

LOWDEFY_SERVER_PORT: É a porta utilizada no servidor. Por default é a porta 3000.

Criar o arquivo .dockerignore com o conteúdo abaixo:

.lowdefy/**
.env

Buildar a imagem no Dockerfile

$ docker build -t <tagNomeQualquer> .

Subir o container da imagem buildada para testar

$ docker run -p 3000:3000 <tagNomeQualquer>

Acesse no browser http://localhost:3000

Uma vez testado, estando OK, pare o container e organizaremos no arquivo docker-compose.yml na imagem container criada anteriormente.

Arquivo docker-compose.yml

$ curl -LO https://raw.githubusercontent.com/lowdefy/lowdefy-example-docker/main/config-in-image/docker-compose.yaml

PS: Esteja atento na indentação do arquivo YAML e o arquivo Dockerfile deve estar no mesmo diretório do arquivo docker-compose.yml

$ docker-compose up -d

Aguarde subir o ambiente, após concluir, acesse no browser http://localhost:3000

Agora, escreve o arquivo YAML no mesmo diretório onde estão os arquivos Dockerfile e docker-compose.yml. Nesse arquivo YAML que criar corresponde a aplicação web por meio de parâmetros específicos, consulte a documentação para certificar para o seu uso.

Referências

https://lowdefy.com/

https://docs.lowdefy.com/tutorial-start

Feito!

segunda-feira, 18 de julho de 2022

Conhecendo a ferramenta Low-Code Saltcorn

O que é Saltcorn?

Saltcorn é uma plataforma Low-Code e No-Code, de código aberto para construir aplicações web com base inicial do banco de dados. Assim as telas do sistema é construída por meio de drag-and-drop.

Pode utilizar o cloud já hospedado, sendo que a sua aplicação ficará no subdomínio da Saltcorn, mas pode instalar na sua máquina ou no seu servidor.

Recomendo instalar o Saltcorn no ambiente Docker, por ser mais simples e rápido.

Instalação e configuração do Saltcorn no ambiente Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

Arquivo docker-compose.yml

$ curl -LO https://raw.githubusercontent.com/saltcorn/saltcorn/master/deploy/examples/test/docker-compose.yml

Arquivo .env

$ curl -LO https://raw.githubusercontent.com/saltcorn/saltcorn/master/deploy/examples/test/.env

Altere o conteúdo do arquivo .env na variável SALTCORN_SECRET por uma string base64.

$ echo "UmaPalavraQualquer" | base64

Coloque o resultado gerado do comando acima na variável SALTCORN_SECRET no arquivo .env

$ docker-compose up -d

Aguarde subir o ambiente, após concluir, acesse no browser http://IP:3000

Pronto, agora faça os seus testes de criação de uma aplicação web com o Saltcorn na técnica Low-Code e Now-Code.

Referências

https://saltcorn.com/

Feito!

sábado, 16 de julho de 2022

Conhecendo o Appsmith

O que é Appsmith?

Appsmith é uma plataforma Low-Code e Now-Code, de código aberto para construir aplicações web, como Dashboards, Paineis Administrativos e muitos outros, de forma 10x mais rápido do que no tradicional.

Pode utilizar no cloud já hospedado com plano gratuito e premium, mas como também pode instalar na sua máquina ou no seu servidor.

Recomendo instalar o Appsmith no ambiente Docker, por ser mais simples e rápido.

Tem suporte de integrações aos bancos relacionais e noSQL (não relacionais), como também outras integrações como Elasticsearch, planilha do Google e API REST.

Instalação e configuração do Appsmith no ambiente Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

Arquivo docker-compose.yml

$ curl -LO https://raw.githubusercontent.com/appsmithorg/appsmith-docs/v1.3/.gitbook/assets/docker-compose.yml

$ docker-compose up -d

Aguarde subir o ambiente, após concluir, acesse no browser http://IP ou https://seudominio.com

Pronto, agora faça os seus testes de criação de uma aplicação web com Appsmith com a técnica Low-Code e Now-Code.

Referências

https://www.appsmith.com/

Feito!

sexta-feira, 15 de julho de 2022

Conhecendo o Tooljet

O que é Tooljet?

Tooljet é plataforma Low-Code e No-Code para criação de aplicações web em JavaScript.

O Tooljet pode utilizar no cloud já hospedado com plano gratuito e premium, mas como é de código aberto, é possível executar na sua máquina local ou no seu próprio servidor.

Recomendo instalar o Tooljet no ambiente Docker, por ser mais simples e rápido.

Tem suporte a integrações aos SGBDs relacionais e noSQL (não relacionais). Também outras integrações como o Elastisearch, Planilha do Google e API REST.

Instalação e configuração do Tooljet no ambiente Docker

A premissa é ter o Docker e Docker-Compose instalados, caso ainda não tenha, verifique Instalando Docker e Docker Compose no Linux (qualquer distro) ou Instalando Docker no Windows 10

Arquivo docker-compose.yml com o SGBD PostgreSQL

$ curl -LO https://raw.githubusercontent.com/ToolJet/ToolJet/main/deploy/docker/docker-compose-postgres.yaml

Renomear o arquivo para docker-compose.yml

$ mv docker-compose-postgres.yaml docker-compose.yaml

Criar o diretório para o volume do banco de dados

$ mkdir postgres_data

Arquivo .env de exemplo com as parametrizações

$ curl -LO https://raw.githubusercontent.com/ToolJet/ToolJet/main/deploy/docker/.env.example

Renomear o arquivo para .env

$ mv .env.example .env

Adicionar no arquivo .env o endereço IP ou o domínio do servidor na variável TOOLJET_HOST

Exemplo:

TOOLJET_HOST=IP_SERVIDOR

OU

TOOLJET_HOST=https://seudominio.com
$ docker-compose up -d

Aguarde subir o ambiente, após concluir, execute os seeds de dados iniciais para o funcionamento do sistema.

$ docker-compose run server npm db:seed

As credenciais de acesso por padrão são: dev@tooljet.io/password

Acesse no browser pelo IP ou seu domínio que definiu no arquivo .env em TOOLJET_HOST, que corresponde ao seu servidor.

Referências

https://www.tooljet.com/

Feito!