Så här installerar du Activepieces med Docker på din server

Activepieces är en automatiseringsplattform som låter dig ansluta applikationer, ta emot webhooks och köra arbetsflöden från ett visuellt gränssnitt. Förutom att använda dess molntjänst kan du Installera Activepieces på din egen server och direkt kontrollera applikationen, databasen och uppdateringarna.

Det rekommenderade sättet att självhosta det är genom att Docker ComposeDen här metoden distribuerar gränssnittet och API:et, arbetarna som ansvarar för att köra flödena, PostgreSQL och Redis separat. En förenklad installation i en enda container är också tillgänglig, även om den är begränsad till personliga projekt och testning.

Att hosta plattformen själv förbättrar kontrollen över infrastrukturen, men det betyder inte att all data automatiskt lagras på servern. När ett flöde använder Gmail, Slack, OpenAI eller ett annat externt API kommer nödvändig information fortfarande att skickas till den leverantören. Därför bör du också Koppla samman agenter och automatiseringar utan att exponera inloggningsuppgifter.

Vilken Activepieces-installation ska du välja?

Activepieces erbjuder två huvudsakliga vägar med Docker. Valet beror på den avsedda användningen, antalet exekveringar och möjligheten att skala infrastrukturen senare.

Facilitet	Komponenter	Rekommenderad användning
Enskild behållare	Applikation, PGLite och minneskö	Personliga tester och projekt
Docker Compose	Applikation, arbetare, PostgreSQL och Redis	Stabil server och utrustning
Produktionsarkitektur	Appar, arbetare, PostgreSQL, Redis och S3-lagring	Hög samtidighet och skalbara implementeringar

Den enskilda behållaren använder PGlite som en integrerad databas och underhåller jobbkön i minnet. Den stöder bara en instans per maskin och kan inte direkt konverteras till en företagsinstallation. Om du senare behöver migrera till den fullständiga arkitekturen måste du förbereda en ny distribution.

Docker Compose är mer lämpligt när du vill bevara flöden i PostgreSQL, använda Redis för köer och separera körningen av automatiseringar med hjälp av arbetare.

Krav för att installera Activepieces med Docker

Den officiella installationen med Docker Compose kräver följande resurser:

• Docker och Docker Compose v2.
• Minst 2 vCPU:er och 4 GB RAM.
• Un Linux-system eller en Docker-kompatibel server.
• WSL2 om du ska köra installationsprogrammet från Windows.
• Åtkomst till en terminal med behörighet att hantera Docker.
• En domän om du behöver ta emot webhooks från internet.
• HTTPS för en offentlig installation eller produktionsinstallation.

Kontrollera att Docker Compose v2 är tillgänglig:

docker compose version

Det korrekta kommandot innehåller ett mellanslag mellan docker y composeDet uråldriga verktyget docker-compose Den motsvarar Compose v1 och fungerar inte med den nuvarande distributionen.

Om du använder Windows, starta upp i en Linux-distribution med WSL2 och kör installationskommandona där. Docker Desktop måste konfigureras för att integrera med den distributionen.

Snabb installation för personliga projekt

Om du bara vill testa Activepieces på en maskin och inte behöver skala upp kan du starta den förenklade versionen med en enda container:

docker run -d --name activepieces -p 8080:80 \
  -v ~/.activepieces:/root/.activepieces \
  -e AP_DB_TYPE=PGLITE \
  -e AP_REDIS_TYPE=MEMORY \
  -e AP_FRONTEND_URL="http://localhost:8080" \
  activepieces/activepieces:latest

Detta kommando:

• Publicera aktiva delar genom hamnen 8080.
• Spara konfigurationen och databasen en ~/.activepieces.
• Använda PGlite som en integrerad databas.
• Hanterar exekveringskön i processminnet.

När behållaren har startat, öppna:

http://localhost:8080

Den första användaren du registrerar blir administratör. Det finns inget standardanvändarnamn eller lösenord..

Den här metoden är inte lämplig för produktion, flera replikeringar eller installationer som kan kräva funktioner på företagsnivå. Om det finns potential att skala projektet, börja direkt med Docker Compose.

Hur man installerar Activepieces med ett enda kommando

Den officiella dokumentationen rekommenderar ett skript som skapar konfigurationen, genererar hemligheterna och startar containrarna. Navigera först till mappen där du vill spara distributionsfilerna och kör:

curl -fsSL https://get.activepieces.com | sh

Om du föredrar att granska innehållet innan du kör det kan du visa det i terminalen:

curl -fsSL https://get.activepieces.com

Installationsprogrammet skapar en mapp som heter activepiecesFörbered filen .env och sätter igång nödvändiga tjänster.

Om port 8080 redan används, ange en annan:

curl -fsSL https://get.activepieces.com | sh -s -- --port 8090

Du kan också välja en annan katalog:

curl -fsSL https://get.activepieces.com | sh -s -- --dir /ruta/activepieces

När du är klar, öppna http://localhost:8080 eller ersätter localhost av serverns IP-adress.

Så här installerar du Activepieces manuellt med Docker Compose

Manuell installation låter dig granska Compose-filen och variablerna innan du startar några containrar. Börja med att klona arkivet:

git clone --depth 1 https://github.com/activepieces/activepieces.git
cd activepieces

Kör sedan skriptet som förbereder filen .env och genererar lösenorden:

sh tools/deploy.sh

Denna process behöver opensslOm det inte är installerat kan skriptet avslutas utan att visa ett uppenbart fel och lämna vissa hemligheter saknade. Kontrollera dem innan du fortsätter:

grep -E '^(AP_ENCRYPTION_KEY|AP_JWT_SECRET|AP_POSTGRES_PASSWORD)=' .env

Alla tre variabler måste innehålla ett värde:

• AP_ENCRYPTION_KEY Kryptera de sparade anslutningarna.
• AP_JWT_SECRET signerar autentiseringstoken.
• AP_POSTGRES_PASSWORD skyddar åtkomst till PostgreSQL.

Installationen använder Community-utgåvan som standard. Om du har en kommersiell licens och vill aktivera den senare måste du förbereda motsvarande utgåva innan du startar distributionen och använda ett kompatibelt körläge.

Vid en manuell installation, tjänsten worker Den måste kunna kommunicera med applikationen med hjälp av containerns interna namn. Kontrollera att dess avsnitt innehåller:

worker:
  environment:
    - AP_CONTAINER_TYPE=WORKER
    - AP_FRONTEND_URL=http://app

Denna adress gäller endast för arbetaren. Variabeln AP_FRONTEND_URL filens general .env Du måste behålla den offentliga URL:en som kommer att användas av externa webbläsare och tjänster.

Slutligen, starta behållarna:

docker compose -p activepieces up -d

Vilka containrar installerar Activepieces?

Implementering med Docker Compose skapar fyra typer av tjänster:

Behållare	Fungera
app	Det tillhandahåller gränssnittet, API:et och plattformsadministrationen.
worker	Den samlar in jobb från kön och kör arbetsflödena.
postgres	Den lagrar flöden, anslutningar, användare och körningar.
redis	Hantera jobbkön och väntande körningar.

PostgreSQL-data sparas inte direkt i den klonade mappen. De finns kvar i Docker-volymen. postgres_dataDärför, Att bara kopiera Activepieces-mappen skapar inte en fullständig säkerhetskopia.

Hur man kontrollerar om Activepieces fungerar

Kontrollera containrarnas status:

docker compose -p activepieces ps

Alla tjänster ska se ut att köras. Kontrollera sedan hälsoslutpunkten:

curl http://localhost:8080/api/v1/health

Logga in och öppna Plattformsadministration > Infrastruktur > ArbetareMinst en arbetare måste vara tillgänglig. Om listan är tom kan arbetaren förmodligen inte kommunicera med applikationen.

Du kan också se register i realtid:

docker compose -p activepieces logs -f app
docker compose -p activepieces logs -f worker

Hur man konfigurerar domänen och webhooks

Activepieces använder AP_FRONTEND_URL för att generera webhook-adresser, OAuth-omdirigeringar och offentliga länkar. Om den innehåller localhostTjänster som Stripe, GitHub eller Slack kommer inte att kunna skicka data från internet.

Redigera filen .env och introducerar det offentliga området:

AP_FRONTEND_URL=https://automatizaciones.tudominio.com

Återskapa sedan tjänsterna för att implementera ändringen:

docker compose -p activepieces up -d

För att utföra tester från en dator utan en offentlig adress kan du använda en tillfällig tunnel:

ngrok http 8080

Ange HTTPS-adressen som tillhandahålls av tunneln i AP_FRONTEND_URL och startar om containrarna. Ngrok är användbart för testning, men dess adress kan ändras och Det bör inte betraktas som en permanent produktionskonfiguration..

Cloudflare Tunnel kan också användas för att publicera instansen utan att direkt öppna port 8080. Du måste dock konfigurera domänen, HTTPS och WebSockets-stödet korrekt.

Hur man skyddar Activepieces med HTTPS

En publik instans måste använda HTTPS. Du kan avsluta krypteringen med hjälp av en omvänd proxy, till exempel Nginx, en lastbalanserare eller proxytjänsten som tillhandahålls av din internetleverantör.

En grundläggande Nginx-konfiguration bör vidarebefordra förfrågningar till port 8080 och tillåta WebSocket-anslutningar:

location / {
    proxy_pass http://localhost:8080;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
}

Certifikatet kan erhållas via Let's Encrypt, Certbot, Cloudflare eller din infrastrukturleverantör. När HTTPS är aktiverat, verifiera att AP_FRONTEND_URL börjar med https://.

Publicera inte PostgreSQL eller Redis direkt på internet. Begränsa även SSH-åtkomst, håll Docker uppdaterad och använd olika lösenord för servern och anslutna applikationer.

Hur man gör en säkerhetskopia

Innan du uppdaterar Activepieces, exportera databasen:

docker compose -p activepieces exec postgres \
  pg_dump -U postgres activepieces > backup.sql

Spara även en säker kopia av filen .envUtan samma AP_ENCRYPTION_KEYActivepieces kommer inte att kunna dekryptera lagrade anslutningar, även om du lyckas återställa PostgreSQL.

I en personlig installation med PGLite måste du säkerhetskopiera följande mapp:

~/.activepieces

Lagra inte säkerhetskopior enbart på samma server. Använd en annan dator, krypterad lagring eller ett versionsbaserat säkerhetskopieringssystem.

Hur man uppdaterar Activepieces

Kontrollera först om det finns inkompatibla ändringar som publicerats för den nya versionen. Efter att du skapat säkerhetskopian, kör:

curl -fsSL https://get.activepieces.com | sh -s -- --upgrade

Installationsprogrammet behåller filen .env, data och ändringar som gjorts i docker-compose.ymlDen använda versionen är fastställd av AP_VERSIONDetta förhindrar oavsiktliga uppdateringar varje gång containrarna startas om.

I den personliga behållaren måste du stoppa den, säkerhetskopiera den ~/.activepieces, ta bort den gamla behållaren, ladda ner den nya avbildningen och återskapa den med samma volym.

Vanliga fel vid installation av Activepieces

Docker compose-kommandot finns inte

Kontrollera versionen:

docker compose version

Om kommandot misslyckas, installera Docker Compose v2. Ersätt inte automatiskt kommandot med docker-compose, eftersom den nuvarande distributionen inte stöder Compose v1.

Port 8080 är redan upptagen

Installera på en annan port:

curl -fsSL https://get.activepieces.com | sh -s -- --port 8090

I en befintlig installation ändras det AP_HOST_PORT inom .env och återskapar containrarna. Ändra inte AP_PORTeftersom den motsvarar den interna porten och kan förstöra mappningen.

Sidan Arbetare visas tom

Kontrollera posterna:

docker compose -p activepieces logs worker | grep -i socket

Upprepade Socket.IO-fel indikerar vanligtvis att arbetaren försöker ansluta till localhost eller till den allmänna domänen inifrån Docker. Konfigurera följande för den tjänsten:

AP_FRONTEND_URL=http://app

Webhooks visar lokalvärd

Ange den allmänna domänen i variabeln AP_FRONTEND_URL från filen .env och starta om tjänsterna. Adressen måste vara tillgänglig från den externa applikation som skickar webhooken.

Testknapparna eller realtidsuppdateringarna fungerar inte

Den omvända proxyn vidarebefordrar förmodligen inte WebSocket-anslutningar korrekt. Kontrollera headern. Upgrade y Connection och aktivera HTTPS, eftersom vissa webbläsare blockerar okrypterade WebSockets.

Nycklarna i .env-filen är tomma.

Installera openssl och kör det igen:

sh tools/deploy.sh

Starta inte installationen förrän du har bekräftat att AP_ENCRYPTION_KEY, AP_JWT_SECRET y AP_POSTGRES_PASSWORD De innehåller värden.

Applikationen fortsätter att starta om

Kontrollera startfelet:

docker compose -p activepieces logs app | grep -i "failed to start"

En möjlig orsak är att använda AP_EDITION=ee tillsammans med AP_EXECUTION_MODE=UNSANDBOXEDEnterprise-utgåvan avvisar denna kombination; den använder ett kompatibelt sandlådeläge som SANDBOX_CODE_ONLY.

Flödena försvinner efter att containrarna har återskapats.

Kontrollera att volymen postgres_data Den finns fortfarande kvar och du har inte utfört en rensningsborttagning. Att ta bort containrar borde inte ta bort volymen, men kommandon som tar bort volymer kan permanent förstöra databasen.

När en automatisering slutar köras kontrollerar den först applikations- och arbetarloggarna. Samma metod är användbar för att fastställa Vad man ska göra när en automatisering misslyckas och separera ett problem från flödet av ett infrastrukturfel.

När behöver man en produktionsarkitektur?

Docker Compose räcker för att komma igång med en egen server, men en organisation med många samtidiga körningar kommer att behöva separera och skala komponenterna.

Den rekommenderade produktionsarkitekturen använder Oberoende arbetare, flera applikationsrepliker, PostgreSQL, Redis och S3-kompatibel lagringKapaciteten bör beräknas baserat på det maximala antalet samtidiga flöden, inte bara det dagliga antalet körningar.

Du bör också konfigurera övervakning, logglagring, verifierade säkerhetskopior och exekveringsisolering. Självhosting ger kontroll, men det flyttar också ansvaret för tillgänglighet, uppdateringar och säkerhet till administratören.

Genom att installera ActivePieces med Docker Compose kan du få en automationsplattform som styrs från din egen infrastruktur. Den viktigaste delen är inte att konfigurera containrarna, utan snarare att välja rätt mellan PGLite och PostgreSQL, skydda hemligheter, konfigurera en stabil publik URL och säkerhetskopiera databasen och krypteringsnyckeln.

Med dessa försiktighetsåtgärder kan du köra flöden, ta emot webhooks och ansluta applikationer utan att förlita dig på Activepieces värdbaserade infrastruktur, samtidigt som du fortfarande kan skala systemet allt eftersom din arbetsbelastning ökar.