Instalando o Bitwarden no Docker
Ambiente Docker
07.11.2025
Reading time: 6 min
Share
Bitwarden é um gerenciador de senhas gratuito e de código aberto que armazena informações confidenciais em um cofre criptografado. Ele é desenvolvido em C#, utilizando .NET Core e ASP.NET Core, e sua base de dados é baseada em T-SQL/SQL Server.
O Bitwarden é um serviço em nuvem acessível por meio de diversos aplicativos clientes, tornando-o multiplataforma: na web, em aplicativos desktop (Windows, macOS, Linux), aplicativos móveis, extensões de navegador (Chrome, Firefox, Safari, Edge, Opera, Vivaldi, Brave, Tor) e também via linha de comando (CLI).
Um dos principais motivos para usar o Bitwarden é evitar gerenciadores de senha de terceiros, onde dados sensíveis ficam armazenados em servidores externos. Em vez disso, é possível hospedar o Bitwarden no seu próprio servidor seguro.
O Bitwarden é composto por um conjunto de contêineres, e cada contêiner contém um componente funcional do sistema — como o banco de dados ou o servidor web. Portanto, para instalar e executar o Bitwarden, é necessário um sistema de containerização, neste caso, o Docker.
Principais recursos do Bitwarden
-
Código aberto (open source)
-
Criptografia AES de 256 bits para proteger os dados do usuário
-
Suporte a autenticação de dois fatores (2FA)
-
Sistema de auditoria e verificação de senhas
-
Suporte a autenticação biométrica
-
Possibilidade de hospedar o servidor localmente
-
Aplicativos clientes multiplataforma em todos os sistemas populares
Pré-requisitos
Este tutorial utiliza comandos para sistemas UNIX-like, em especial Debian/Ubuntu, amplamente usados para deploys de servidores.
Antes de instalar e configurar o Bitwarden, garanta que os pacotes do sistema estejam atualizados:
sudo apt update
sudo apt upgrade
Se o servidor for novo, instale algumas ferramentas básicas:
sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
Em seguida, certifique-se de ter Docker e Docker Compose instalados para gerenciar os contêineres do Bitwarden.
Passo 1: Instalar o Docker e seus componentes
Adicione a chave GPG oficial do Docker, usada para assinar pacotes:
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
Depois, adicione o repositório do Docker para obter a versão mais recente:
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
Atualize novamente o sistema:
sudo apt update
Por fim, instale o Docker e o Docker Compose:
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose
Passo 2: Proteger a instalação do Bitwarden
Para aumentar a segurança, crie um usuário dedicado com permissões limitadas.
Crie o diretório do Bitwarden:
sudo mkdir /opt/bitwarden
Crie o usuário:
sudo adduser bitwarden
Defina as permissões e o proprietário do diretório:
sudo chmod -R 700 /opt/bitwarden
sudo chown -R bitwarden:bitwarden /opt/bitwarden
Permita que o usuário Bitwarden execute comandos Docker:
sudo usermod -aG docker bitwarden
Em seguida, troque para o usuário Bitwarden:
su bitwarden
cd /opt/bitwarden
Passo 3: Instalar o Bitwarden no Docker e iniciar o servidor
Mesmo que você não tenha experiência com Docker, os desenvolvedores do Bitwarden fornecem um script de instalação automatizado.
Baixe o script e torne-o executável:
curl -Lso bitwarden.sh https://go.btwrdn.co/bw-sh && chmod 700 bitwarden.sh
Execute o script:
./bitwarden.sh install
Durante a instalação, o script pedirá várias informações, como:
-
O domínio do servidor Bitwarden
-
O nome do banco de dados
-
Se deseja usar o Let’s Encrypt para emitir um certificado SSL gratuito
Você também precisará informar um ID de instalação e uma chave, que podem ser gerados no site oficial do Bitwarden.
Passo 4: Configurar o servidor de e-mail SMTP
Embora seja opcional, é recomendável configurar um servidor SMTP para permitir o envio de e-mails administrativos. Edite o arquivo ./bwdata/env/global.override.env e adicione as variáveis de configuração, por exemplo:
globalSettings__mail__smtp__host=smtp.gmail.com
globalSettings__mail__smtp__port=587
globalSettings__mail__smtp__ssl=true
globalSettings__mail__smtp__username=seu_email@gmail.com
globalSettings__mail__smtp__password=sua_senha
adminSettings__admins=seu_email@gmail.com
Se você já domina Docker, pode utilizar um servidor de e-mail em contêiner, como o docker-mailserver, que funciona muito bem com o Bitwarden. Em um cenário mais simples (embora menos seguro), é possível usar um servidor público como o Gmail:
globalSettings__mail__replyToEmail=seu_email@gmail.com
globalSettings__mail__smtp__host=smtp.gmail.com
globalSettings__mail__smtp__username=seu_email
globalSettings__mail__smtp__password=sua_senha
globalSettings__mail__smtp__ssl=true
globalSettings__mail__smtp__port=587
globalSettings__mail__smtp__useDefaultCredentials=false
globalSettings__disableUserRegistration=true
Após configurar, o Bitwarden enviará notificações por meio da sua conta do Gmail. Certifique-se de ativar a opção “permitir aplicativos menos seguros” em sua conta, caso contrário o Google poderá bloquear o envio.
Se estiver usando outro provedor de e-mail, consulte as configurações SMTP (endereço do host, porta, SSL, etc.) e adicione-as de forma equivalente. Se o envio falhar, utilize uma ferramenta de teste SMTP online para validar e ajustar as configurações.
Passo 5: Iniciar o servidor e verificar o funcionamento
Inicie o servidor com o mesmo script:
./bitwarden.sh start
Abra o navegador e acesse o servidor usando o IP ou domínio configurado. Para abrir o painel de administração, adicione /admin ao final da URL.
A página solicitará o endereço de e-mail configurado no arquivo global.override.env. O servidor de e-mail enviará um link para login sem senha, que dá acesso direto ao painel administrativo.
A partir daí, você pode utilizar qualquer cliente Bitwarden — desktop, web ou mobile — para conectar-se ao seu servidor e gerenciar senhas com segurança.
Parar e remover o servidor
Caso surjam problemas ou você deseje reinstalar o Bitwarden, interrompa completamente o serviço:
./bitwarden.sh stop
Remova o diretório de dados:
rm -r ~/bwdata
E reinstale, se necessário:
./bitwarden.sh install
Conclusão
A instalação do Bitwarden é simples, já que o script fornecido pelos desenvolvedores automatiza grande parte do processo. Após configurá-lo, você poderá proteger seus dados sensíveis com este gerenciador de senhas robusto, utilizando DNS, SSL e SMTP conforme necessário. Para mais detalhes e boas práticas, consulte a documentação oficial do Bitwarden.
Ambiente Docker
07.11.2025
Reading time: 6 min
Share
Semelhante
Ambiente Docker
Configurando registros Docker externos
Configurando registros Docker externos
Ao trabalhar com Docker, você lida com imagens — arquivos executáveis que contêm tudo o que é necessário para executar uma aplicação, incluindo o código-fonte, as bibliotecas e as dependências. Essas imagens são armazenadas em repositórios especializados chamados registros, que podem ser privados ou públicos.
O registro público mais conhecido é o Docker Hub, onde é possível encontrar diversas imagens oficiais como Nginx, PostgreSQL, Alpine, Ubuntu, Node e MongoDB. Usuários podem se registrar no Docker Hub e armazenar suas próprias imagens — por padrão, com um registro público e três registros privados. O Docker Hub é o registro padrão usado pelo Docker para baixar (pull) imagens.
Este guia explica como alterar o registro padrão do Docker para outro.
Usando registros Docker externos
Uma maneira simples de utilizar registros externos é recorrer aos oferecidos por empresas como Google e Amazon.Abaixo estão alguns registros públicos que você pode usar:
URL do registro
Proprietário
https://mirror.gcr.io
Google
https://public.ecr.aws
Amazon
https://quay.io
Red Hat
https://registry.access.redhat.com
Red Hat
https://registry.redhat.io
Red Hat
⚠️ Atenção: o uso de registros externos pode representar riscos de segurança. Use com cuidado.
Siga os passos abaixo para substituir o Docker Hub por outro registro padrão.
Configuração no Linux
Abra o arquivo daemon.json com um editor de texto.
Se o Docker estiver instalado em modo normal (não rootless), o arquivo estará localizado em:
/etc/docker/daemon.json
Se o arquivo não existir, crie-o com:
nano /etc/docker/daemon.json
Para o Docker em modo rootless, o arquivo fica no diretório pessoal do usuário:
~/.config/docker/daemon.json
Crie o arquivo se ele não existir:
nano ~/.config/docker/daemon.json
Adicione o seguinte parâmetro para definir um novo registro padrão (neste exemplo, o mirror do Google):
{
"registry-mirrors": ["https://mirror.gcr.io"]
}
Salve e feche o arquivo.
Reinicie o serviço do Docker para aplicar as alterações:
systemctl reload docker
A partir de agora, o Docker utilizará o novo registro para baixar imagens.
Por exemplo, para baixar a imagem Alpine do registro do Google:
docker pull mirror.gcr.io/alpine
Você também pode especificar uma versão específica:
docker pull mirror.gcr.io/nginx:1.25.2
Configuração no Windows (Docker Desktop)
Abra o arquivo daemon.json, localizado em:
C:\Users\<seu_nome_de_usuário>\.docker\daemon.json
Adicione o parâmetro:
{
"registry-mirrors": ["https://mirror.gcr.io"]
}
Salve o arquivo e reinicie o Docker. Clique com o botão direito no ícone do Docker na barra de tarefas e selecione Restart.
Também é possível configurar o registro pela interface do Docker Desktop:acesse Settings → Docker Engine e adicione:
{
"registry-mirrors": ["https://mirror.gcr.io"]
}
Clique em Apply & Restart para salvar as mudanças e reiniciar o Docker. Após o reinício, o Docker usará o novo registro para os downloads.Por exemplo, para baixar a imagem curl:
docker pull mirror.gcr.io/curlimages/curl
Ou uma versão específica:
docker pull mirror.gcr.io/node:21-alpine
Usando Nexus como registro Docker
Você também pode usar o Nexus para gerenciar imagens Docker. O Nexus oferece suporte a repositórios proxy, que armazenam em cache imagens baixadas de registros externos, como o Docker Hub. Assim, o Nexus pode funcionar como um registro proxy com cache, útil quando registros externos estão temporariamente indisponíveis.
Configurando um repositório proxy no Nexus
Faça login no Nexus com uma conta administradora ou com permissão para criar repositórios.
Vá em Server Administration and Configuration → Repositories.
Clique em Create repository e selecione o tipo docker (proxy).
Preencha os seguintes campos:
Name: defina um nome exclusivo para o repositório.
Online: mantenha esta opção marcada para permitir conexões.
Proxy server: se o Nexus estiver atrás de um proxy (como Nginx), não será necessário configurar portas de autenticação.Caso contrário, atribua uma porta única para HTTP ou HTTPS.
Allow anonymous docker pull: se ativado, não será necessário autenticar com docker login.Se desativado, o login será obrigatório antes de baixar imagens.
Remote storage: informe o endereço do registro externo (por exemplo, https://registry-1.docker.io para o Docker Hub).
Após criar o repositório, faça login no registro Nexus (se necessário):
docker login <endereco_registro_nexus>
Para baixar uma imagem, use o formato:
docker pull <endereco_registro_nexus>/nome_imagem:tag
Exemplo: baixar a imagem Python com a tag 3.8.19-alpine:
docker pull nexus-repo.com/python:3.8.19-alpine
⚠️ Dica de segurança: evite usar a tag latest, pois ela pode conter bugs ou vulnerabilidades.
Conclusão
Neste artigo, foram apresentadas várias formas de baixar e armazenar imagens Docker. O uso de registros externos pode ser útil quando o Docker Hub está indisponível. Se você não confia em registros públicos, pode criar e hospedar seu próprio registro Docker, seja ele privado ou público, usando ferramentas como Nexus ou Harbor.
05 November 2025 · 5 min to read
Ambiente Docker
Executando o Selenium com o Chrome no Docker
Às vezes, é útil trabalhar com o Selenium em Python dentro de um contêiner Docker. Isso levanta dúvidas sobre os benefícios dessa abordagem, a compatibilidade entre o ChromeDriver e o Chromium, e as particularidades de sua implementação. Neste artigo, abordaremos os principais pontos e apresentaremos soluções para os problemas mais comuns.
Por que executar o Selenium no Docker?
Executar o Selenium em um contêiner traz várias vantagens:
🧩 Portabilidade – Permite transferir facilmente o ambiente entre diferentes máquinas, evitando conflitos de versão e dependências específicas do sistema operacional.
🧱 Isolamento – O contêiner Selenium pode ser atualizado ou substituído rapidamente, sem afetar outros componentes do servidor.
⚙️ Compatibilidade com CI/CD – O Selenium em contêineres se integra perfeitamente a pipelines de CI/CD, permitindo iniciar um ambiente de teste limpo a cada execução.
Preparando um servidor Ubuntu para o Selenium com Docker
Antes de começar, verifique se o Docker e o Docker Compose estão instalados:
docker --version && docker compose version
💡 Em algumas versões, o comando é docker-compose (com hífen) em vez de docker compose.
Se as ferramentas estiverem instaladas, as versões serão exibidas. Caso contrário, siga o guia de instalação correspondente.
Exemplo: Selenium no Docker
Ao usar o Selenium em contêineres Docker, leve em consideração a arquitetura do host, os requisitos funcionais e o desempenho.
As imagens oficiais selenium/standalone-* foram projetadas para CPUs AMD64 (x86_64), enquanto as imagens seleniarm/standalone-* são adaptadas para arquiteturas ARM (como Apple Silicon ou servidores ARM64).
Crie um arquivo docker-compose.yml na raiz do projeto:
version: "3"
services:
app:
build: .
restart: always
volumes:
- .:/app
depends_on:
- selenium
platform: linux/amd64
selenium:
image: selenium/standalone-chromium:latest # For AMD64
# image: seleniarm/standalone-chromium:latest # For ARM64
container_name: selenium-container
restart: unless-stopped
shm_size: 2g
ports:
- "4444:4444" # Selenium WebDriver API
- "7900:7900" # VNC Viewer
environment:
- SE_NODE_MAX_SESSIONS=1
- SE_NODE_OVERRIDE_MAX_SESSIONS=true
- SE_NODE_SESSION_TIMEOUT=300
- SE_NODE_GRID_URL=http://localhost:4444
- SE_NODE_DETECT_DRIVERS=false
Escolha a imagem correta para a sua arquitetura descomentando a linha apropriada. O serviço app executará o seu código Python. Crie um Dockerfile para definir esse serviço:
# Use a minimal Python image
FROM python:3.11-slim
# Set working directory
WORKDIR /app
# Install Python dependencies
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt
# Copy project files
COPY . /app/
# Set environment variables (Chromium is in a separate container)
ENV SELENIUM_REMOTE_URL="http://selenium:4444/wd/hub"
# Run Python script
CMD ["python", "main.py"]
Esse Dockerfile usa uma imagem leve de Python e instala automaticamente as dependências necessárias.
Script principal (main.py)
import time # Used to create a delay for checking browser functionality
import os
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
# WebDriver settings
chrome_options = Options()
chrome_options.add_argument("--no-sandbox")
chrome_options.add_argument("--disable-dev-shm-usage")
chrome_options.add_argument("--disable-gpu")
chrome_options.add_argument("--disable-webrtc")
chrome_options.add_argument("--hide-scrollbars")
chrome_options.add_argument("--disable-notifications")
chrome_options.add_argument("--start-maximized")
SELENIUM_REMOTE_URL = os.getenv("SELENIUM_REMOTE_URL", "http://selenium:4444/wd/hub")
driver = webdriver.Remote(
command_executor=SELENIUM_REMOTE_URL,
options=chrome_options
)
# Open a test page
driver.get("https://www.hostman.com")
time.sleep(9999)
# Shut down WebDriver
driver.quit()
requirements.txt
attrs==25.1.0
certifi==2025.1.31
h11==0.14.0
idna==3.10
outcome==1.3.0.post0
PySocks==1.7.1
selenium==4.28.1
sniffio==1.3.1
sortedcontainers==2.4.0
trio==0.28.0
trio-websocket==0.11.1
typing_extensions==4.12.2
urllib3==2.3.0
websocket-client==1.8.0
wsproto==1.2.0
Iniciando os contêineres
Para iniciar os contêineres:
docker compose up -d
O Docker construirá e iniciará os contêineres em segundo plano.
Verifique o status com:
docker compose ps
Se dois contêineres estiverem ativos, tudo está funcionando corretamente — você pode interagir com sites diretamente via Selenium.
Depuração do Selenium no Docker com VNC
Nas imagens oficiais do Selenium (como selenium/standalone-chrome ou seleniarm/standalone-chromium), o acesso direto ao Chrome DevTools Protocol (CDP) é gerenciado pelo Selenium Grid. Cada sessão gera uma nova porta WebSocket, o que torna impossível o acesso direto de fora do contêiner.
Argumentos como --remote-debugging-port=9229 são ignorados ou substituídos. Por isso, essas imagens oferecem suporte VNC integrado (Virtual Network Computing), semelhante a TeamViewer ou AnyDesk.
⚠️ O modo headless deve estar desativado, pois o VNC transmite a tela real — e se ela estiver vazia, nada será exibido.
Acesse a interface web do VNC em:
http://<server_ip>:7900
Ao conectar, será solicitado um senha. Para criá-la, entre no contêiner Selenium:
docker exec -it selenium-container bash
x11vnc -storepasswd
Digite e confirme a senha. Em seguida, use-a na interface web do VNC para acessar o navegador controlado pelo Selenium. A partir daí, é possível abrir as DevTools, inspecionar elementos DOM e depurar solicitações de rede.
Conclusão
Executar o Selenium em contêineres Docker simplifica a portabilidade do ambiente e elimina conflitos de versão. Além disso, permite depuração visual via VNC, quando necessário.
Certifique-se apenas de:
escolher a imagem correta (AMD64 ou ARM64),
e desativar o modo headless se desejar usar uma interface gráfica.
Essa abordagem oferece uma infraestrutura de testes flexível, estável e facilmente integrável a pipelines CI/CD.
30 October 2025 · 6 min to read
Tem perguntas,
comentários ou preocupações?
Nossos profissionais estão disponíveis para ajudá-lo a qualquer momento,
seja para assistência ou apenas se você não souber por onde começar.
seja para assistência ou apenas se você não souber por onde começar.
