Construindo uma Plataforma de Notas Open-Source: Outline

O prazer de experimentar

Por que construri sua própria plataforma de notas? Não há um motivo específico, apenas um desejo repentino de experimentar. Às vezes, uma ideeia simplesmente surge, e uma pesquisa revela uma solução adequada, então você decide experimentar.

Na verdade, já existem muitas ferramentas de maduras como Notion/OneNote, mas quem não gostaria de ter suas notas armazenadas completamente em seu próprio servidor?

Iniciando a construção

Esta configuração pode ser complicada, exigindo vários componentes:

  • redis
  • postgresql
  • minio
  • keycloak

Plataformas que dependem de múltiplos imagens geralmente são recomendadas para serem implantadas com docker-compose, mas prefiro iniciar contêineres Docker um por um. Os contêineres do postgres e redis podem ser reutilizados, não sendo necessário iniciar um novo toda vez, e o docker-compose também pode passar variáveis de ambiente.

Fontes Docker podem ser encontradas em: https://www.wangdu.site/course/2109.html, atualmente uso docker.mybacc.com, basta adicionar ao pull da imagem e renomear a imagem. As fontes ficam obsoletas rapidamente, então modificar o arquivo de fonte toda vez é mais trabalhoso.

Além disso, a solicitação de certificados requer as portas 80/443, e como uso um computador local sem portas 80 e 443 públicas, só posso implantar serviços http, o que impossibilita o login por e-mail durante os testes.

redis

docker pull docker.mybacc.com/redis:7.4.2-alpine

docker tag docker.mybacc.com/redis:7.4.2-alpine redis:7.4.2-alpine

docker rmi docker.mybacc.com/redis:7.4.2-alpine

docker run -d \
    --name redis-container \
    -p 6379:6379 \
    -v ~/docker-data/redis-info:/data \
    redis:7.4.2-alpine \
    redis-server --save 60 1 --loglevel warning --requirepass senha123

postgresql

docker pull docker.mybacc.com/postgres:15.12

docker run -d \
	--name banco-postgres \
	-e POSTGRES_PASSWORD=senha_segura \
	-e POSTGRES_USER=usuario_admin \
	-v ~/docker-data/postgres-info:/var/lib/postgresql/data \
	-p 5432:5432 \
	postgres:15.12

minio

https://github.com/minio/minio

Este é um serviço de arquivos, usado no Outline como armazenamento de imagens. Você pode copiar imagens diretamente para a página para fazer upload ao MinIO, mas a exclusão pode precisar ser feita diretamente no MinIO, algo que será investigado posteriormente.

docker pull minio/minio:RELEASE.2025-03-12T18-04-18Z

docker run -d \
    --name servidor-minio \
    -p 29000:9000 \
    -p 29001:9001 \
    -e MINIO_REGION_NAME="regiao-local-1" \
    -e MINIO_ROOT_USER="admin_minio" \
    -e MINIO_ROOT_PASSWORD="senha_minio_forte" \
    -v ~/docker-data/minio-info:/data \
    minio/minio:RELEASE.2025-03-12T18-04-18Z server /data --console-address ":9001"

Após a criação, crie um novo Bucket chamado outline, preenchendo apenas o nome e mantendo o resto padrão.

Em seguida, configure a Região (se você definiu a variável de ambiente MINIO_REGION_NAME durante a inicialização, aqui deve ter um valor), com um nome de sua preferência, salve e será necessário reiniciar. Este valor será usado posteriormente como AWS_REGION.

keycloak

https://github.com/keycloak/keycloak

A função exata do Keycloak é complexa de explicar, mas no contexto do Outline, ele serve para autenticação de usuários.

docker run -d \
    --name auth-keycloak \
    -p 8080:8080 \
    -e KC_DB=postgres \
    -e KC_DB_URL=jdbc:postgresql://ip:porta/nome_banco \
    -e KC_DB_USERNAME=usuario_banco \
    -e KC_DB_PASSWORD=senha_banco \
    -e KC_BOOTSTRAP_ADMIN_USERNAME=admin_keycloak \
    -e KC_BOOTSTRAP_ADMIN_PASSWORD=senha_admin_keycloak \
    keycloak/keycloak:26.1.4 start-dev
  • KC_DB: Tipo de banco de dados a ser usado, opções incluem: mariadb, mssql, mysql, oracle, postgres. Se encontrar problemas, experimente as versões recomendadas no site oficial
  • KC_DB_URL: URL de conexão com o banco, que precisa ser criado previamente
  • KC_DB_USERNAME: Usuário do banco de dados
  • KC_DB_PASSWORD: Senha do banco de dados
  • KC_BOOTSTRAP_ADMIN_USERNAME: Usuário do Keycloak, definido por você
  • KC_BOOTSTRAP_ADMIN_PASSWORD: Senha do Keycloak, definida por você

Ao iniciar, uma mensagem vermelha aparecerá avisando para não usar o modo desenvolvedor (start-dev) em produção. Usar start forçaria HTTPS, o que é complicado. Alternativamente, você pode usar o镜像 steveltn/https-portal para configurar HTTPS com um clique, mas requer as portas 80 e 443 para solicitar certificados.

Ao acessar a interface web através da porta 8080, uma mensagem "HTTPS required" pode impedir o login normal. Entre no shell do contêiner e execute dois comandos para ignorar isso:

docker exec -it auth-keycloak bash
/opt/keycloak/bin/kcadm.sh config credentials --server http://localhost:8080 --realm master --user admin
Digite a senha definida e execute o seguinte comando
/opt/keycloak/bin/kcadm.sh update realms/master  -s sslRequired=NONE

Atualize a página e agora poderá fazer login normalmente. Comece criando um realm chamado outline

Em seguida, crie um Client no realm outline

O terceiro valor deve ser o endereço onde o Outline será implantado, com porta, como no exemplo abaixo:

Root URL: http://seudominio.example.com:3000/
Home URL: http://seudominio.example.com:3000/
Valid redirect URIs: http://seudominio.example.com:3000/*

Copie o conteúdo da aba Credentials (Client Secret), pois este será o valor de OIDC_CLIENT_SECRET mais tarde.

Crie um usuário para fazer login, que será usado para acessar o Keycloak.

Defina uma senha para este usuário. Você pode desativar a opção Temporary para que o usuário não precise modificar a senha no primeiro login.

Ainda é necessário desabilitar o SSL no Outline:

docker exec -it auth-keycloak bash
/opt/keycloak/bin/kcadm.sh config credentials --server http://localhost:8080 --realm master --user admin
Digite a senha definida e execute o seguinte comando
/opt/keycloak/bin/kcadm.sh update realms/outline  -s sslRequired=NONE

outline

Agora que tudo está configurado, basta iniciar o Outline

docker pull outlinewiki/outline:0.82.0

docker run -d \
    -p 3000:3000 \
    --name plataforma-outline \
    -v ~/docker-data/outline-info:/var/lib/outline/data \
    -e DATABASE_URL=postgres://usuario:senha@dominio:porta/nome_banco \
    -e REDIS_URL=redis://:senha_redis@dominio:porta/0 \
    -e PGSSLMODE=disable \
    -e FORCE_HTTPS=false \
    -e SECRET_KEY=chave_secreta_personalizada \
    -e UTILS_SECRET=segredo_utilitarios \
    -e URL=http://dominio:3000 \
    -e OIDC_CLIENT_ID=outline_id \
    -e OIDC_CLIENT_SECRET=segredo_cliente_oidc \
    -e OIDC_AUTH_URI=http://dominio:porta/realms/outline/protocol/openid-connect/auth \
    -e OIDC_TOKEN_URI=http://dominio:porta/realms/outline/protocol/openid-connect/token \
    -e OIDC_USERINFO_URI=http://dominio:porta/realms/outline/protocol/openid-connect/userinfo \
    -e OIDC_USERNAME_CLAIM=preferred_username \
    -e OIDC_DISPLAY_NAME=autenticacao_keycloak \
    -e OIDC_SCOPES="openid profile email" \
    -e AWS_ACCESS_KEY_ID=chave_acesso_minio \
    -e AWS_SECRET_ACCESS_KEY=senha_acesso_minio \
    -e AWS_S3_UPLOAD_BUCKET_URL=http://dominio:porta \
    -e AWS_S3_UPLOAD_BUCKET_NAME=outline \
    -e AWS_REGION=regiao_local_1 \
    -e FILE_STORAGE_UPLOAD_MAX_SIZE=26214400 \
    -e AWS_S3_FORCE_PATH_STYLE=true \
    -e AWS_S3_ACL=private \
    outlinewiki/outline:0.82.0

As variáveis de ambiente podem ser consultadas em: https://github.com/outline/outline/blob/main/.env.sample

  • DATABASE_URL: Informações de conexão com o banco PostgreSQL
  • REDIS_URL: Informações de conexão com o Redis
  • PGSSLMODE: Desabilita SSL na conexão com o PostgreSQL
  • FORCE_HTTPS: Desabilita o forçamento de HTTPS
  • SECRET_KEY: Pode ser gerada com openssl rand -hex 32
  • UTILS_SECRET: Pode ser gerada com openssl rand -hex 32
  • URL: Endereço de acesso ao Outline, IP mais porta mapeada
  • OIDC_CLIENT_ID: Client ID definido no Keycloak
  • OIDC_CLIENT_SECRET: Client Secret da aba Credentials no Keycloak
  • OIDC_AUTH_URI: Esturtura do link: http://dominio_keycloak:porta_keycloak/realms/realm_keycloak/protocol/openid-connect/auth
  • OIDC_TOKEN_URI: Mesma estrutura acima
  • OIDC_USERINFO_URI: Mesma estrutura acima
  • OIDC_USERNAME_CLAIM: Mantenha como está
  • OIDC_DISPLAY_NAME: Pode ser qualquer nome
  • AWS_ACCESS_KEY_ID: Usuário do MinIO
  • AWS_SECRET_ACCESS_KEY: Senha do MinIO
  • AWS_S3_UPLOAD_BUCKET_URL: Endereço de conexão com MinIO, porta 9000 (não 9001, que é a interface web)
  • AWS_S3_UPLOAD_BUCKET_NAME: Nome do bucket
  • AWS_REGION: Região configurada
  • FILE_STORAGE_UPLOAD_MAX_SIZE: Tamanho máximo de upload, 25MB neste caso
  • AWS_S3_FORCE_PATH_STYLE: Mantenha como está
  • AWS_S3_ACL: Mantenha como está

Acesse a porta do Outline e será redirecionado para a tela de login do Keycloak. Insira o usuário e senha criados anteriormente para fazer login com sucesso. Copiar imagens para a página também permitirá o upload normal. Vou testar antes de dar uma avaliação final.

Aqui fica evidente a vantagem do docker-compose.

Links de referência

  • Documentação oficial do Keycloak: https://www.keycloak.org/guides#server
  • Construindo Wiki e Base de Conhecimento Pessoal com Outline: https://luckzym.com/posts/a239536c/
  • Implantando Outline com armazenamento local usando Docker: https://blog.csdn.net/networken/article/details/141961843
  • Documentação oficial do Outline: https://docs.getoutline.com/s/hosting/doc/hosting-outline-nipGaCRBDu

Tags: Docker outline postgresql Redis MinIO

Publicado em 7-28 01:42

Tags em Destaque

©2026 Doido Dev