Miljöguide · ca 35-45 min (setup, portar, secrets, deploy) ← → Space 1 / …

Miljöguide · lokal drift

Kom igång med Docker Compose för vår AI + CRM-stack

Den här guiden förklarar vad som behöver finnas lokalt, hur ni startar vår Compose-miljö på macOS och Windows, vilka tjänster som faktiskt går igång, hur portar fungerar och varför Docker gör samma stack enklare att förstå både lokalt och vid deploy.

macOS Windows Docker Desktop Portar Tjänstenamn Secrets Deploy-tänk

Målet: efter den här genomgången ska ni kunna säga vad som startar, var ni öppnar det, hur containrarna pratar och vilka variabler som måste finnas för att hela flödet ska bli användbart.

Det ni får med er
  • En fungerande startsekvens med docker compose.
  • En mental modell för localhost kontra interna tjänstenamn.
  • En överblick över hela stacken: React, n8n, Flowise, Chatwoot, Twenty och stödcontainers.
  • En enkel modell för hur env vars och secrets hör ihop.
Laptop -> Docker Compose
  -> portar pa hosten
  -> containrar pa samma natverk
  -> samma kontrakt lokalt och vid deploy

Varför vi gör så här

Docker Compose löser ett undervisningsproblem innan det löser ett driftproblem

Utan en gemensam miljö

  • Varje elev installerar saker på olika sätt.
  • Olika versioner av Postgres, Redis eller Node ger olika fel.
  • Det blir svårt att avgöra om felet sitter i kod eller i maskinen.

Med Docker Compose

  • Samma tjänster och samma portar startar för alla.
  • Vi kan prata om en och samma arkitektur i klassrummet.
  • Ni får en repeterbar miljö där flödet går att starta, stoppa, läsa och felsöka.

I kursen är Compose alltså inte bara "ett sätt att deploya". Det är ett sätt att ge alla samma laborationsyta och samma systemgränser.

Det viktiga är inte att "köra Docker". Det viktiga är att ni kan förstå hela kedjan från browser till n8n, AI, CRM och support utan att lokala installationer drar isär berättelsen.

Vad som behövs lokalt

macOS och Windows: samma stack, lite olika startyta

macOS
  • Installera Docker Desktop for Mac.
  • Starta Docker Desktop och vänta tills motorn är igång.
  • Öppna Terminal eller iTerm i projektmappen.
  • Se till att portarna 3000, 3001, 3002, 5678, 8083, 8084 och 8085 är lediga.
  • Om ni vill ha riktiga AI-svar: exportera OPENAI_API_KEY innan start.
macOS / zsh / bash
export OPENAI_API_KEY="sk-..."
docker compose up -d
Windows
  • Installera Docker Desktop for Windows.
  • Aktivera gärna WSL2-backend i Docker Desktop.
  • Öppna PowerShell eller Windows Terminal i projektmappen.
  • Samma portar måste vara lediga som på macOS.
  • Om ni vill ha riktiga AI-svar: sätt OPENAI_API_KEY i PowerShell innan start.
Windows / PowerShell
$env:OPENAI_API_KEY="sk-..."
docker compose up -d

Vanligaste missen i början: man kör kommandon innan Docker Desktop faktiskt är klart. Börja först när ni ser att Docker-motorn är igång.

Kommandon i rätt ordning

Första uppstart: minsta fungerande sekvens för den här miljön

Steg för steg

  • Gå till projektroten där docker-compose.yml ligger.
  • Kör docker compose up -d för att starta miljön i bakgrunden.
  • På en helt ny Chatwoot-volym: kör docker compose run --rm chatwoot-rails bundle exec rails db:chatwoot_prepare en gång.
  • Kör sedan docker compose up -d igen om ni vill vara säkra på att allt är uppe.
  • Kontrollera status med docker compose ps.

Praktiska kommandon

docker compose up -d

docker compose run --rm chatwoot-rails \
  bundle exec rails db:chatwoot_prepare

docker compose up -d
docker compose ps
docker compose logs -f n8n

Första körningen kan ta ett tag: images dras ned, och demo-web installerar npm-paket innan React-demon blir tillgänglig.

Compose-filen i praktiken

Det här är tjänsterna som ingår i vår lokala miljö

Det ni normalt öppnar i browsern

Tjänst URL Roll
Projektportal http://localhost:8084 Startsida med länkar, status och presentationer
React Demo Store http://localhost:8083 Bosses Akvariefiskar som postar till n8n
Legacy Freetext Case http://localhost:8085 Regex- och dataprocesseringsövning
n8n http://localhost:5678 Webhookar, logik, routing och HTTP-anrop
Flowise http://localhost:3000 AI-lager och chatflows
Chatwoot http://localhost:3001 Support- och chattyta
Twenty http://localhost:3002 CRM för personer och affärer

Det som också startar i bakgrunden

  • chatwoot-postgres och chatwoot-redis bär Chatwoots data och köer.
  • chatwoot-sidekiq kör bakgrundsjobb åt Chatwoot.
  • twenty-db och twenty-redis bär Twenty.
  • twenty-worker kör bakgrundsjobb åt CRM-lagret.
  • All trafik i den här guiden går via publicerade localhost-portar i Compose.

Poängen är att ni inte manuellt installerar Postgres, Redis, Rails, Node och Python på hosten. Compose startar en sammanhängande miljö där varje del har sitt eget ansvar.

Host mot container

Så fungerar portar: vänster sida är din dator, höger sida är containern

Om en port på vänster sida redan används på din dator kommer Compose inte kunna publicera tjänsten. Då behöver ni frigöra porten eller ändra mappningen.

Nätverk inifrån och utifrån

localhost utifrån, tjänstenamn inifrån

På hosten, alltså från browsern

  • http://localhost:5678 öppnar n8n.
  • http://localhost:3000 öppnar Flowise.
  • http://localhost:3001 öppnar Chatwoot.
  • http://localhost:3002 öppnar Twenty.
Browser -> localhost:5678
Browser -> localhost:3000

Mellan containers på Compose-nätverket

  • n8n anropar Flowise via http://flowise:3000.
  • n8n anropar Twenty via http://twenty:3000.
  • n8n anropar Chatwoot API via http://chatwoot-rails:3000.
  • Chatwoot ska anropa n8n via webhook. I UI: ofta http://host.docker.internal:5678/webhook/chatwoot (accepteras som giltig URL). Internt i Docker: http://n8n:5678/webhook/chatwoot.
Container -> flowise:3000
Container -> twenty:3000
Container -> n8n:5678

Den klassiska missen är att skriva localhost inne i en container. Där betyder localhost containern själv, inte din laptop och inte någon annan tjänst i Compose.

Stacken som helhet

Så ser vår lokala stack ut när allt kör

Portal

project-index

Startsida på localhost:8084 som gör det lätt att hitta demos, slides och ingångar.

Insamling

demo-web

React-demon på localhost:8083 som skickar leads och supportsignaler vidare till n8n.

Övningscase

legacy-ugly-web

Freetext- och SQLite-caset på localhost:8085 för regex- och dataprocessering.

Orkestrering

n8n

Tar emot webhookar, håller ihop logik och skickar data vidare till rätt destination.

AI-lager

Flowise

Kapslar chatflows, promptlogik och AI-svar så att AI-delen blir ett tydligt eget lager.

Affär & support

Twenty + Chatwoot

CRM för leads och affärer, plus supportyta för chatt och konversationer.

I bakgrunden finns också databaser, Redis och workers. De syns mindre i browsern, men utan dem blir varken Chatwoot eller Twenty särskilt användbara.

Efter första start

Det här behöver ni konfigurera för att hela kedjan ska bli meningsfull

Flowise

  • Skapa eller importera chatflows för kursens scenarier.
  • Sätt FLOWISE_LEAD_CHATFLOW_ID.
  • Sätt FLOWISE_SUPPORT_CHATFLOW_ID.
  • Valfritt: FLOWISE_CHATWOOT_CHATFLOW_ID för särskilt chattflöde.

Twenty

  • Skapa API-nyckel i Twenty.
  • Lägg den i TWENTY_API_KEY för n8n.
  • n8n använder också TWENTY_API_BASE=http://twenty:3000 internt.

OpenAI

  • OPENAI_API_KEY går till Flowise.
  • Utan nyckeln kan stacken starta, men AI-svaren blir tomma eller mindre användbara.

Chatwoot

  • För svar tillbaka till chatten behövs CHATWOOT_API_ACCESS_TOKEN.
  • Webhook till n8n: http://host.docker.internal:5678/webhook/chatwoot i Chatwoot-formulär, eller http://n8n:5678/webhook/chatwoot om UI tillåter det.

När ni ändrar env vars för en tjänst räcker det ofta att starta om just den tjänsten, till exempel docker compose up -d n8n eller docker compose up -d flowise.

Env vars och hemligheter

Så ska ni tänka om secrets: demo först, riktig hemlighetshantering sen

I kursdemot

  • Målet är att komma igång snabbt och kunna visa hela arkitekturen.
  • Ni kommer se env vars som styr URL:er, chatflow-id:n och tokens.
  • Vissa demo-defaults finns för att tröskeln ska vara låg i klassrummet.

I riktig drift

  • Riktiga API-nycklar och tokens ska ligga i .env eller i en riktig secret manager.
  • Commit:a inte riktiga secrets till git.
  • Byt demo-lösenord, app secrets och tokens innan något lämnar labbmiljön.
# Exempel pa sekretkontrakt, inte riktiga varden
OPENAI_API_KEY=sk-...
TWENTY_API_KEY=...
FLOWISE_LEAD_CHATFLOW_ID=...
FLOWISE_SUPPORT_CHATFLOW_ID=...
FLOWISE_CHATWOOT_CHATFLOW_ID=...
CHATWOOT_API_ACCESS_TOKEN=...

Skillnaden mellan konfiguration och hemlighet är viktig: en port eller URL kan ofta vara offentlig, men en API-nyckel, app secret eller access token ska behandlas som känslig information.

Varför Docker är smidigt att deploya

Samma kontrakt från laptop till server, men inte samma risknivå

Varför det är smidigt

  • Samma images och samma tjänstegränser kan köras lokalt och på en server.
  • Compose beskriver hela miljön: tjänster, portar, env vars, volymer och beroenden.
  • Det minskar "works on my machine"-problemet vid överlämning.
  • Det blir lättare att deploya om bara en tjänst utan att tänka om hela systemet.

Vad som ändå saknas för riktig prod

  • Riktiga domäner, TLS/HTTPS och säkrare ingress.
  • Riktig secret-hantering och roterade nycklar.
  • Backup-strategi för databaser och volymer.
  • Övervakning, loggning och säkrare lösenord än demo-defaults.

Docker gör alltså deploy mer repeterbar, inte automatiskt mer färdig. Det ni vinner är samma struktur, samma kontrakt och tydligare tjänstegränser.

I den här miljön använder vi medvetet direkta localhost-portar för att hålla setupen enkel, tydlig och likadan för alla i klassrummet.

Avslutning

Vanliga missar och snabb checklista för att komma igång

Vanliga missar

  • En annan process använder redan porten ni behöver.
  • Docker Desktop eller WSL2-backend är inte igång trots att terminalen är öppen.
  • Ni ändrar en env var men glömmer att starta om den berörda tjänsten.
  • Ni använder localhost inne i en container i stället för tjänstenamn.
  • Ni förväntar er AI-svar utan att OPENAI_API_KEY är satt.
  • Ni vill ha en "ren" miljö men glömmer att volymer sparar data mellan omstarter.

Snabb checklista

  1. Starta Docker Desktop.
  2. Kör docker compose up -d.
  3. Kör Chatwoot-prepare en gång på ny volym.
  4. Öppna portal, n8n, Flowise, Twenty och Chatwoot.
  5. Sätt Flowise-id:n, Twenty API key och eventuellt OpenAI/Chatwoot-token.
  6. Importera workflows i n8n och chatflows i Flowise.
  7. Skicka första leadet och följ körningen i n8n.

Om miljön går att starta på både macOS och Windows med samma Compose-fil har ni redan vunnit något viktigt: arkitekturen är tydligare än maskinen.