SSD Nodes Learn Hosting plans →

Docker తో VPS పై Chatwoot self-host ఎలా చేయాలి

Docker Compose, Traefik తో VPS పై Chatwoot అమలు చేయండి. pinned tags, SMTP పంపకం, Postgres మరియు uploads బ్యాకప్‌లు, అలాగే సురక్షిత upgrades కోసం స్పష్టమైన దశలు ఇక్కడ ఉన్నాయి.

మీరు ఏమి నిర్మిస్తున్నారు

VPS పై Chatwoot ను self-host చేయడానికి మీరు నాలుగు containers ను నడుపుతారు: ఒక Rails web process, ఒక Sidekiq background worker, pgvector extension తో కూడిన PostgreSQL, మరియు Redis. Chatwoot అనేది ఒక open source customer support desk, కాబట్టి మీరు నియంత్రించే సర్వర్‌లో ఒక shared team inbox మరియు website chat widget లభిస్తాయి. ఈ ఇన్‌స్టాలేషన్ సుమారు ఇరవై నిమిషాలు పడుతుంది. ఆ తర్వాత వచ్చే మెయిల్ డెలివరీ, బ్యాకప్‌లు, అప్‌గ్రేడ్‌లు మరియు సైజింగ్ వంటి అంశాలే, ఒక సంవత్సరం తర్వాత కూడా ఈ సేవ నడుస్తుందా లేదా అని నిర్ణయిస్తాయి.

ప్రతి container కు ఒకే పని ఉంటుంది. Rails ఏజెంట్ డాష్‌బోర్డ్ మరియు widget API (application programming interface) ను అందిస్తుంది. Sidekiq నెమ్మదిగా జరిగే పనులను చేస్తుంది: ఇమెయిల్ పంపడం, కనెక్ట్ చేయబడిన ఛానెల్‌లను పోల్ చేయడం, ఆటోమేషన్ నియమాలను అమలు చేయడం మరియు రిపోర్టులను రూపొందించడం. Postgres సంభాషణలు, కాంటాక్ట్‌లు, ఏజెంట్ ఖాతాలు మరియు మీరు డాష్‌బోర్డ్‌లో మార్చే ప్రతి సెట్టింగ్‌ను భద్రపరుస్తుంది. Redis లో Sidekiq క్యూలు మరియు ActionCable pub/sub ఛానెల్ ఉంటాయి, ఇవి పేజీని రీలోడ్ చేయకుండానే కొత్త సందేశాన్ని ఓపెన్ డాష్‌బోర్డ్‌లోకి పంపుతాయి. ఇక్కడ Redis కేవలం తాత్కాలిక cache కాదు, ఎందుకంటే అది పోతే క్యూలో ఉన్న పనులు కూడా పోతాయి.

Upstream compose ఫైల్‌లోని Postgres ఇమేజ్ స్టాక్ postgres ఇమేజ్ కాకుండా pgvector/pgvector:pg16 గా ఉంటుంది, ఎందుకంటే Chatwoot యొక్క schema దాని AI ఫీచర్ల కోసం vector extension ను ఎనేబుల్ చేస్తుంది. ఒకవేళ మీరు స్టాక్ Postgres ను ఉపయోగిస్తే, ఆ ఇమేజ్‌లో extension యొక్క కంట్రోల్ ఫైల్ లేనందున మొదటి డేటాబేస్ రన్ ERROR: extension "vector" is not available తో ఆగిపోతుంది. Upstream వారు అందించే ఇమేజ్‌నే వాడండి.

ఈ గైడ్ మీ సర్వర్‌లో Docker మరియు reverse proxy ఇప్పటికే పనిచేస్తున్నాయని భావిస్తుంది. ఒకవేళ అవి లేకపోతే, Docker Compose on a VPS తో ప్రారంభించి తిరిగి రండి.

Self-hosted Chatwoot కు ఎంత VPS అవసరం?

2026 అక్టోబర్ నాటికి upstream requirements page కనీసంగా 4 GB RAM మరియు 4 CPU cores కోరుతోంది. ఈ స్థాయి రోజుకు గరిష్ఠంగా 10,000 conversations వరకు నిర్వహించగలదని పేర్కొంటోంది. 8 GB RAM మరియు 8 cores ఉన్న వ్యవస్థ రోజుకు గరిష్ఠంగా 20,000 conversations వరకు నిర్వహించగలదని చెబుతోంది. కనీసం 1 GB swap కూడా అవసరం. కారణాన్ని కూడా స్పష్టంగా ఇస్తోంది: upgrade సమయంలో machine memory అయిపోకుండా ఉండటానికి. File uploads ను లెక్కలోకి తీసుకోకముందు Postgres కోసం 5 GB నుంచి 10 GB disk కేటాయించండి.

ఇప్పుడు స్పష్టంగా చెప్పాలంటే, 2 GB VPS లో Chatwoot ప్రారంభమవుతుంది. ఇద్దరు agents మరియు తక్కువ activity ఉన్న inbox తో అది సరిగానే కనిపిస్తుంది. కానీ రెండు సందర్భాల్లో విఫలమవుతుంది. మొదటిది Sidekiq. Busy server లో ఇది 1 GB కంటే ఎక్కువ memory ఉపయోగిస్తుందని upstream కొలిచింది. అందువల్ల email లేదా report job అకస్మాత్తుగా పెరిగితే, Rails, Postgres మరియు Redis తమ memory భాగాన్ని తీసుకునేలోపే machine memory పరిమితిని దాటుతుంది. రెండవది upgrade. ఎందుకంటే migrations అమలు చేయడానికి db:chatwoot_prepare కొత్త Rails process ను ప్రారంభిస్తుంది. ఈ image లో Rails boot ఉపయోగకరమైన పని ప్రారంభించేలోపే వందల MB memory ఉపయోగిస్తుంది.

ముందుగా మీకు స్పష్టమైన warning రాదు. Kernel యొక్క out of memory killer తాను ఎంచుకున్న process కు SIGKILL పంపుతుంది. సాధారణంగా అది అత్యధిక memory ఉపయోగిస్తున్న process అయి ఉంటుంది. Docker ఆ container ఆగిపోయిందని గుర్తించి, restart: always దాన్ని మళ్లీ ప్రారంభిస్తుంది. తరువాత docker compose ps --all నిరంతరం restarting అవుతున్న container ను లేదా Exited (137) వద్ద ఉన్న container ను చూపిస్తుంది. ఇక్కడ 137 అంటే signal 9 వల్ల process terminate అయిందని అర్థం. --all లేకపోతే stopped container అసలు జాబితాలో కనిపించదు. Exit code 137 మాత్రమే memory కారణమని నిరూపించదు. ఎందుకంటే docker kill కూడా అదే signal పంపుతుంది. అందువల్ల kernel ఎంచుకున్న process పేరును చూపించే sudo dmesg -T | grep -i "killed process" తో నిర్ధారించండి.

4 GB మీ బడ్జెట్‌కు మించినదైతే, 2 GB machine ను 2 GB swap తో నడపండి. Load పెరిగినప్పుడు response times ఎక్కువ అవుతాయని అంగీకరించాలి. Swap memory అయిపోకుండా ఉండేందుకు ఉపయోగపడే buffer మాత్రమే; ఇది హామీ కాదు. Burst తగినంత ఎక్కువగా ఉంటే container అయినా terminate కావచ్చు. ఏ పరిస్థితిలోనైనా ప్రతి service కు hard memory ceiling నిర్ణయించడం మంచిది. అప్పుడు worker దానితో పాటు database ను కూడా down చేయలేడు. Docker Compose లో memory limits చూడండి.

File uploads కు మీరు నిర్ణయించిన పరిమితి లేకపోతే అవే నిరంతరం పెరుగుతాయి. Customer జత చేసే ప్రతి screenshot storage volume లో చేరి అక్కడే ఉంటుంది. అందువల్ల disk నిండింది database వల్లేనని అనుకోకుండా docker system df -v ను monitor చేయండి.

Compose ఫైల్‌ను పొందండి, version tag ను pin చేయండి

mkdir -p ~/chatwoot && cd ~/chatwoot
wget -O .env https://raw.githubusercontent.com/chatwoot/chatwoot/develop/.env.example
wget -O docker-compose.yaml https://raw.githubusercontent.com/chatwoot/chatwoot/develop/docker-compose.production.yaml
chmod 600 .env

మీరు ఇప్పుడే download చేసిన ఫైల్‌లో image: chatwoot/chatwoot:latest ఉంది. మరేదైనా చేయడానికి ముందు దాన్ని మార్చండి.

services:
  base: &base
    image: chatwoot/chatwoot:v4.19.1
    env_file: .env
    volumes:
      - storage_data:/app/storage

latest అంటే తర్వాతి docker compose pull ఆ ఉదయం publish చేసిన దానినే మీకు ఇస్తుంది. అది మీరు చదవని migrations కలిగిన major version కావచ్చు. Chatwoot migrations ఆచరణలో reversible కావు. అందువల్ల అనుకోకుండా version మారితే undo చేయడం సాధ్యం కాదు; backup నుంచి restore చేయాలి. Tag ను pin చేసి, దాన్ని ఉద్దేశపూర్వకంగా మార్చండి. 25 October 2026 నాటికి v4.19.1 ప్రస్తుత release. తాజా security fixes మరియు hardening improvements కోసం దాన్ని సిఫార్సు చేస్తున్నట్లు release notes చెబుతున్నాయి. ఈ రోజు మీరు pin చేయాల్సిన tag కోసం releases page చూడండి. మీరు v4.18.0 లేదా అంతకంటే పాత version నుంచి upgrade చేస్తుంటే ముందుగా v4.19.0 notes చదవండి: Captain V1 retired అయింది. V1 instructions ఉపయోగించే self-hosted installations upgrade చేయడానికి ముందు వాటిని V2 కు migrate చేయాలి. Database ను నిర్వహించే ఏ software కైనా ఇదే జాగ్రత్త అవసరం. అందుకే openGym workout tracker ను self-host చేయడం ఈ application కంటే చాలా చిన్నదైనప్పటికీ git tag ను ముందుగా pin చేయడంతో ప్రారంభమవుతుంది.

base service ఒక YAML anchor. rails మరియు sidekiq రెండూ దాన్ని merge చేస్తాయి. కాబట్టి tag ను ఒకచోట మార్చితే అది రెండింటికీ మారుతుంది. మీరు ఫైల్‌లో ఉన్నప్పుడే పైభాగంలోని version: '3' line ను తొలగించండి. Modern Compose దాన్ని పట్టించుకోదు. ప్రతి command సమయంలో the attribute 'version' is obsolete, it will be ignored ను print చేస్తుంది.

.env ఫైల్‌ను నింపండి

ముందుగా secret ను రూపొందించండి. అక్షరాలు మరియు అంకెలు మాత్రమే ఉన్న విలువను ఉపయోగించాలని upstream సూచిస్తుంది, ఎందుకంటే ప్రత్యేక అక్షరాలు shell లేదా YAML parser ద్వారా వెళ్ళేటప్పుడు పాడయ్యే అవకాశం ఉంది.

head /dev/urandom | tr -dc A-Za-z0-9 | head -c 63 ; echo ''

ఆ తర్వాత .env లో ఈ కీలను సెట్ చేయండి.

SECRET_KEY_BASE=<the 63 characters you just generated>
FRONTEND_URL=https://support.example.com
FORCE_SSL=true
DEFAULT_LOCALE=en
ENABLE_ACCOUNT_SIGNUP=true

POSTGRES_HOST=postgres
POSTGRES_USERNAME=postgres
POSTGRES_PASSWORD=<long random string>
POSTGRES_DATABASE=chatwoot

REDIS_URL=redis://redis:6379
REDIS_PASSWORD=<a different long random string>

RAILS_ENV=production
INSTALLATION_ENV=docker
ACTIVE_STORAGE_SERVICE=local

POSTGRES_HOST=postgres మరియు redis://redis:6379 అనేవి Compose సర్వీస్ పేర్లు, ఇవి ప్రాజెక్ట్ యొక్క డిఫాల్ట్ నెట్‌వర్క్‌లో రిజాల్వ్ అవుతాయి. FRONTEND_URL అనేది కేవలం అలంకారం కాదు. Chatwoot విడ్జెట్ స్క్రిప్ట్ URL ను మరియు బయటకు వెళ్లే ప్రతి ఇమెయిల్‌లోని లింక్‌లను దీని ఆధారంగానే నిర్మిస్తుంది, కాబట్టి తప్పుడు విలువను ఇస్తే, పాస్‌వర్డ్ రీసెట్ లింక్‌లు స్పందించని హోస్ట్‌కు దారితీస్తాయి.

ఇప్పుడు upstream ఫైల్‌లో ఉన్న ఒక చిక్కు ఉంది. postgres సర్వీస్ .env ను చదవదు. ఇది సొంతంగా environment బ్లాక్‌ను కలిగి ఉంటుంది, అందులో POSTGRES_PASSWORD= ఖాళీగా ఉంటుంది. కాబట్టి .env లో మాత్రమే పాస్‌వర్డ్‌ను సెట్ చేస్తే, డేటాబేస్‌కు పాస్‌వర్డ్ ఉండదు, కానీ అప్లికేషన్‌కు ఉంటుంది. సర్వీస్‌ను అదే వేరియబుల్‌కు పాయింట్ చేయండి:

  postgres:
    image: pgvector/pgvector:pg16
    restart: always
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=chatwoot
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}

Compose ప్రాజెక్ట్ డైరెక్టరీ నుండి .env ను ${...} సబ్‌స్టిట్యూషన్ కోసం చదువుతుంది, కాబట్టి ఇప్పుడు రెండు వైపులా ఒకే స్ట్రింగ్ ఉంటుంది. ఇది తప్పుగా ఉంటే, Rails PG::ConnectionBad: FATAL: password authentication failed for user "postgres" తో ఆగిపోతుంది.

ఒక ప్రవర్తన అందరినీ ఆశ్చర్యపరుస్తుంది: Postgres ఇమేజ్ POSTGRES_PASSWORD ను కేవలం ఖాళీ డేటా డైరెక్టరీని ప్రారంభించేటప్పుడు మాత్రమే వర్తింపజేస్తుంది. ఆ తర్వాత విలువను మార్చినా ఎటువంటి ప్రభావం ఉండదు, ఎందుకంటే initdb రెండోసారి రన్ అవ్వదు. మీరు ఇప్పటికే stack ను ఒకసారి ప్రారంభించి ఉంటే, డేటాబేస్ లోపలే దాన్ని మార్చండి.

docker compose exec postgres psql -U postgres -c "ALTER USER postgres WITH PASSWORD 'the-new-password';"

ENABLE_ACCOUNT_SIGNUP=true అనేది తాత్కాలికమైనది. ఇది పబ్లిక్ రిజిస్ట్రేషన్ ఫారమ్‌ను తెరుస్తుంది, తద్వారా మీరు మొదటి ఖాతాను సృష్టించవచ్చు. దీన్ని false గా సెట్ చేయండి మరియు మీ ఖాతా సృష్టించబడిన వెంటనే docker compose up -d ను మళ్ళీ రన్ చేయండి, లేకపోతే URL తెలిసిన ఎవరైనా మీ సపోర్ట్ డెస్క్‌లో రిజిస్టర్ చేసుకోవచ్చు. ఆ తర్వాత ఏజెంట్లు ఆహ్వానం ద్వారా మాత్రమే వస్తారు మరియు వారి పాస్‌వర్డ్‌లు ఈ యాప్‌లోనే ఉంటాయి. మీరు అరడజను సేవలను నడుపుతూ, ప్రతిదానికీ విడివిడి ఖాతాల జాబితాను నిర్వహించడం విసుగు తెప్పిస్తే, అప్పుడు Authentik వంటి self-hosted identity provider వాటి స్థానంలో ఉపయోగపడుతుంది.

.env ఇప్పుడు ఈ stack కు సంబంధించిన ప్రతి secret ను plain text లో కలిగి ఉంది, కాబట్టి దీన్ని mode 600 లో ఉంచండి మరియు git లోకి వెళ్లకుండా చూడండి. Compose env ఫైళ్లను ఎలా చదువుతుంది మరియు secrets ఎక్కడ లీక్ అవుతాయి అనే అంశం, env_file మరియు environment మధ్య వ్యత్యాసంతో సహా, ఇందులో ఉన్న ప్రమాదకరమైన అంశాలను వివరిస్తుంది.

మీ ప్రస్తుత Traefik వెనుక Chatwoot ను ఉంచడం

ఒకే అప్లికేషన్ కోసం రెండవ reverse proxy ని నిర్మించవద్దు. ఈ సర్వర్‌లో ఇతర కంటైనర్ల కోసం Traefik ఇప్పటికే TLS (transport layer security) ను నిర్వహిస్తుంటే, Chatwoot ను ఒక label block ద్వారా దానికి అనుసంధానించవచ్చు. ఒకవేళ మీరు ఇంకా అలా చేయకపోతే, అనేక Docker Compose అప్లికేషన్ల ముందు Traefik ను ఒకసారి సెటప్ చేసి, ఆపై ఇక్కడికి తిరిగి రండి.

అప్‌స్ట్రీమ్ యొక్క docker-compose.yaml ను యథాతథంగా ఉంచండి, తద్వారా మీరు దానిని భవిష్యత్తులో కొత్త కాపీతో పోల్చి (diff) చూడవచ్చు. మీ మార్పులను ఒక override ఫైల్‌లో ఉంచండి. Compose స్వయంచాలకంగా docker-compose.override.yaml ను విలీనం చేస్తుంది, మరియు Compose ను బహుళ ఫైళ్లుగా విభజించడం అనే అంశం ఈ విలీన నియమాలను వివరిస్తుంది.

services:
  rails:
    networks:
      - default
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.chatwoot.rule=Host(`support.example.com`)"
      - "traefik.http.routers.chatwoot.entrypoints=websecure"
      - "traefik.http.routers.chatwoot.tls.certresolver=letsencrypt"
      - "traefik.http.services.chatwoot.loadbalancer.server.port=3000"

networks:
  proxy:
    external: true

మీ స్వంత entrypoint మరియు certresolver పేర్లను ఉపయోగించండి. కంటైనర్ తప్పనిసరిగా Traefik ఉన్న అదే Docker నెట్‌వర్క్‌లో ఉండాలి, దీని కోసమే proxy ఎంట్రీని ఉపయోగిస్తాము. అలాగే, అది default లో కూడా ఉండాలి, లేకపోతే అది Postgres మరియు Redis కనెక్షన్‌లను కోల్పోతుంది. చాలామంది మర్చిపోయేది ఈ రెండవ లైన్ గురించే.

ports: బ్లాక్‌ను మార్చవద్దు. అప్‌స్ట్రీమ్ దీనిని 127.0.0.1:3000 కి బైండ్ చేస్తుంది, ఇది కేవలం loopback మాత్రమే. కాబట్టి ఇది ఇంటర్నెట్ నుండి అందుబాటులో ఉండదు, కానీ curl -I http://127.0.0.1:3000 ఉపయోగించి సర్వర్ లోపల నుండి పరీక్షించడానికి ఇది ఉపయోగకరంగా ఉంటుంది.

ఏజెంట్ డాష్‌బోర్డ్ లైవ్ మెసేజ్ డెలివరీ కోసం /cable కి ఒక websocket ను ఓపెన్‌గా ఉంచుతుంది. Traefik ఎటువంటి అదనపు కాన్ఫిగరేషన్ లేకుండానే HTTP upgrade ను ఫార్వార్డ్ చేస్తుంది, కాబట్టి దీని కోసం ప్రత్యేకంగా ఏమీ జోడించాల్సిన అవసరం లేదు. ఒకవేళ మీరు భవిష్యత్తులో Traefik ముందు ఒక CDN లేదా మరొక proxy ని ఉంచితే, అక్కడ websockets ను అనుమతించండి. లేకపోతే, డాష్‌బోర్డ్ సాధారణంగా లోడ్ అవుతుంది కానీ కొత్త సందేశాలు మాత్రం మాన్యువల్‌గా రిఫ్రెష్ చేసిన తర్వాతే కనిపిస్తాయి.

డేటాబేస్‌ను ప్రారంభించి, స్టాక్‌ను రన్ చేయడం

ముందుగా డేటా సేవలను ప్రారంభించండి, Postgres తన మొదటి రన్‌ను పూర్తి చేసే వరకు వేచి ఉండండి.

docker compose up -d postgres redis
docker compose logs postgres | tail -n 5

database system is ready to accept connections కోసం వేచి ఉండండి. ఆ తర్వాత స్కీమాను క్రియేట్ చేయండి.

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

ఇది డేటాబేస్ లేకపోతే కొత్తగా సృష్టిస్తుంది, ఆపై స్కీమాను మరియు డిఫాల్ట్ సీడ్ డేటాను లోడ్ చేస్తుంది. ఇది మైగ్రేషన్ లైన్లను ప్రింట్ చేసి, విజయవంతంగా ముగుస్తుంది. ఒకవేళ ఇది postgres:5432 - no response అని ప్రింట్ చేస్తూ ఆగిపోతే, ఎంట్రీ పాయింట్ ఇంకా కనెక్షన్‌లను స్వీకరించని డేటాబేస్ కోసం వేచి ఉంటోందని అర్థం. మొదటిసారి రన్ చేస్తున్నప్పుడు, సాధారణంగా initdb ఇంకా పని చేస్తూ ఉండటం వల్ల ఇలా జరుగుతుంది. వేచి ఉండండి, Postgres లాగ్స్‌ను చదవండి, ఆపై మళ్ళీ రన్ చేయండి. ఒకవేళ ఇది vector ఎక్స్‌టెన్షన్ వద్ద ఆగిపోతే, మీరు pgvector ఇమేజ్‌ను స్టాక్ Postgres తో భర్తీ చేశారని అర్థం.

docker compose up -d
docker compose ps
docker compose logs --tail 30 rails

నాలుగు కంటైనర్లు Up అని చూపించాలి, మరియు రైల్స్ లాగ్ చివరలో Puma http://0.0.0.0:3000 పోర్ట్ వద్ద వింటున్నట్లు (listening) ఉండాలి. ఆ తర్వాత పబ్లిక్ పాత్‌ను తనిఖీ చేయండి:

curl -sI https://support.example.com | head -n 1

HTTP/2 200 అంటే మొత్తం చైన్ సరిగ్గా పనిచేస్తోందని అర్థం. Traefik నుండి 404 ఎర్రర్ వస్తే, రౌటర్ రూల్ మ్యాచ్ కాలేదని అర్థం, సాధారణంగా హోస్ట్‌నేమ్ టైపింగ్ తప్పుగా ఉండటం వల్ల ఇలా జరుగుతుంది. 502 ఎర్రర్ అంటే Traefik రౌటర్‌ను మ్యాచ్ చేసింది కానీ కంటైనర్‌ను చేరుకోలేకపోయిందని అర్థం. ఇది దాదాపు ఎప్పుడూ proxy నెట్‌వర్క్ లేకపోవడం వల్ల లేదా loadbalancer.server.port పోర్ట్ 3000 కాకపోవడం వల్ల జరుగుతుంది.

URLని ఓపెన్ చేయండి, /app/auth/signup వద్ద మీ ఖాతాను సృష్టించండి, ఆపై ENABLE_ACCOUNT_SIGNUP=false సెట్ చేసి, ఫారమ్‌ను క్లోజ్ చేయడానికి docker compose up -d రన్ చేయండి.

SMTP లేకుండా password resetలు మరియు email conversations ఎందుకు విఫలమవుతాయి

SMTP (simple mail transfer protocol) settings లేకుండా ఉన్న Chatwoot email పంపలేని support deskగా మారుతుంది. దాంతో notifications మాత్రమే కాదు, మరెన్నో పనులు కూడా విఫలమవుతాయి. Password resetలు పనిచేయడం ఆగిపోతుంది. అందువల్ల admin account నుంచి బయటపడితే తిరిగి access పొందలేడు. Agent invitations కూడా పనిచేయవు, ఎందుకంటే invitation ఒక email. Email conversationలో customerకు reply ఇవ్వడం కూడా ఆగిపోతుంది. దీంతో conversation ఒకే దిశలో మాత్రమే కొనసాగుతుంది. చాలామంది ఈ దశను దాటవేస్తారు. తరువాత అత్యంత అవసరమైన సమయంలో ఈ సమస్యను గుర్తిస్తారు.

విధానం సులభంగా అర్థమవుతుంది. SMTP_ADDRESS సెట్ చేయకపోతే Chatwoot mail delivery కోసం ActionMailerను sendmailకు మార్చుతుంది. Upstream documentationలో ఇది Postfix setupగా ఉంది. v2.12.0 నుంచి ఇది defaultగా ఉంది. దాని సూచనల ప్రకారం serverపై Postfixను sudo apt install -y postfix తో install చేయాలి. ఈ Docker setupలో అది ఎక్కడా జరగదు. అందువల్ల ఆ deliveryకి mail అప్పగించడానికి configured mail server ఉండదు. Mail background job నుంచి పంపబడుతుంది. కాబట్టి delivery ఉత్పత్తి చేసే error Sidekiq logలో నమోదవుతుంది, Rails logలో మాత్రం కనిపించదు. ఇదిలా ఉండగా "forgot password"ను క్లిక్ చేసిన వ్యక్తికి విజయవంతమైనట్లు కనిపించే confirmation వస్తుంది, కానీ email మాత్రం అందదు.

MAILER_SENDER_EMAIL=Support <support@example.com>
SMTP_DOMAIN=example.com
SMTP_ADDRESS=smtp.example.com
SMTP_PORT=587
SMTP_USERNAME=support@example.com
SMTP_PASSWORD=<the relay password>
SMTP_AUTHENTICATION=plain
SMTP_ENABLE_STARTTLS_AUTO=true

STARTTLSతో port 587ను ఉపయోగించండి. ఇది మొదట plain textలో connectionను తెరిచి, authenticationకు ముందు దాన్ని encrypted connectionగా మారుస్తుంది. Spamను పరిమితం చేయడానికి అనేక VPS providers outbound port 25ను defaultగా block చేస్తాయి. 8 November 2026 నాటికి, Hetzner cloud serversలో ports 25 మరియు 465ను defaultగా block చేస్తుంది. ఈ blocking ప్రతి accountకు వర్తిస్తుంది. Vultr కొత్త Compute Instances అన్నింటిలో port 25ను block చేస్తుంది. Unblock requests రెండూ case-by-caseగా పరిశీలిస్తాయి. Limit request సమర్పించడానికి ముందు Hetznerలో customerగా ఒక నెల పూర్తై ఉండాలి. మొదటి invoiceను కూడా చెల్లించి ఉండాలి. Hetzner మరియు Vultr రెండూ port 587ను block చేయవు. అందువల్ల 587పై relay మొదటి boot నుంచే ticket లేదా వేచి ఉండటం లేకుండా పనిచేస్తుంది. SMTP_DOMAIN అనేది SMTP conversation సమయంలో మీ server ప్రకటించే domain. కొన్ని relays ఈ domain సరిపోలకపోతే requestను reject చేస్తాయి.

Settingsను వర్తింపజేసి workerను monitor చేయండి:

docker compose up -d rails sidekiq
docker compose logs -f sidekiq

Login page నుంచి password resetను ప్రారంభించండి. Delivery సరిగ్గా పనిచేస్తే Sidekiq logలో mailer job సాధారణంగా పూర్తవుతుంది. విఫలమైతే ముందుగా exception class కనిపిస్తుంది. తరువాత Sidekiq పెరుగుతున్న backoffతో retry చేస్తుంది. అందువల్ల పనిచేయని relay ప్రతి కొన్ని నిమిషాలకు గంటల పాటు అదే errorను ఉత్పత్తి చేస్తుంది.

రెండు rejectionలు సాధారణంగా కనిపిస్తాయి. వీటిలో ఏదీ Chatwoot bug కాదు. 535 Authentication failed అంటే authentication విఫలమైందని అర్థం. అందువల్ల credentials, SMTP authentication enable అయిందా లేదా access policy దాన్ని block చేస్తుందా అనేది పరిశీలించాలి. Credentials సరిగ్గా ఉండటం మాత్రమే ఈ errorను తొలగించదు. కొంతమంది providers account passwordకు బదులుగా application passwordను కోరుతారు. 550 Sender address rejected అంటే server sender addressను reject చేసిందని అర్థం. MAILER_SENDER_EMAIL మార్చే ముందు పూర్తి responseను చదవండి. Sender permissions లేదా verification ఒక కారణం కావచ్చు. అయితే sender domainకు null MX record ఉన్నప్పుడు 550 5.7.27 Sender address rejected: Domain does not accept mail కనిపిస్తుంది.

Conversationలోకి emailను స్వీకరించడం వేరే పని. Chatwoot ingress ద్వారా forwarding కోసం MAILER_INBOUND_EMAIL_DOMAIN మరియు RAILS_INBOUND_EMAIL_SERVICE అవసరం. Incoming messagesను Chatwootకు అప్పగించే mail server కూడా అవసరం. ఆ forwarding pathను ఏర్పాటు చేయకుండా IMAP ద్వారా mailboxను connect చేయవచ్చు. ఇందులో Google లేదా Microsoft OAuth కూడా ఉన్నాయి. Relayను అద్దెకు తీసుకోవడం వేగవంతమైన మార్గం. మొత్తం mail pathను మీరే నిర్వహించాలనుకుంటే, Mailcowతో మీ స్వంత mail serverను నడపడం ఆ బాధ్యతలో వాస్తవంగా ఏమి ఉంటుందో వివరిస్తుంది.

ఏమి బ్యాకప్ చేయాలి మరియు రీస్టోర్ పనిచేస్తుందని ఎలా నిర్ధారించుకోవాలి

Chatwoot బ్యాకప్‌లో నాలుగు భాగాలు ఉంటాయి. వీటిలో దేనిని వదిలేసినా, రీస్టోర్ ప్రక్రియ కేవలం రీబిల్డ్ (rebuild) గా మారుతుంది.

  • Postgres డేటాబేస్: ఇందులో సంభాషణలు, కాంటాక్టులు, ఏజెంట్ ఖాతాలు మరియు ప్రతి సెట్టింగ్ ఉంటాయి.
  • storage_data వాల్యూమ్: ఎందుకంటే ACTIVE_STORAGE_SERVICE=local అప్‌లోడ్ చేసిన ఫైళ్లను డిస్క్‌లో సేవ్ చేస్తుంది, Postgresలో కేవలం ఒక రిఫరెన్స్ రో (row) మాత్రమే ఉంచుతుంది.
  • .env ఫైల్: ఎందుకంటే ఇందులో SECRET_KEY_BASE మరియు ACTIVE_RECORD_ENCRYPTION_* కీలు ఉంటాయి.
  • Compose ఫైళ్లు: మీ డేటాబేస్ స్కీమాకు సరిపోయే ఖచ్చితమైన ఇమేజ్ ట్యాగ్‌ను ఇవి నమోదు చేస్తాయి.

డేటాబేస్‌ను మాత్రమే రీస్టోర్ చేస్తే, సంభాషణలు తిరిగి వస్తాయి కానీ అటాచ్‌మెంట్లు పనిచేయవు. ఎందుకంటే డేటాబేస్ రోలు డిస్క్‌లో లేని ఫైళ్లను సూచిస్తాయి.

cd ~/chatwoot
docker compose exec -T postgres pg_dump -U postgres -Fc chatwoot > db-$(date +%F).dump

-T ముఖ్యం. ఇది లేకపోతే, Compose ఒక సూడో టెర్మినల్‌ను కేటాయిస్తుంది. ఇది స్ట్రీమ్‌లోని న్యూలైన్ బైట్‌లను మారుస్తుంది, దీనివల్ల pg_restore తిరస్కరించే డంప్ ఫైల్ తయారవుతుంది. -Fc అనేది కస్టమ్ ఫార్మాట్, ఇది డేటాను కంప్రెస్ చేస్తుంది మరియు pg_restore ఎంపిక చేసిన రీతిలో పనిచేయడానికి అనుమతిస్తుంది.

docker run --rm -v chatwoot_storage_data:/data:ro -v "$PWD":/backup alpine \
  tar czf /backup/storage-$(date +%F).tgz -C /data .

వాల్యూమ్ పేరు మీ ప్రాజెక్ట్ డైరెక్టరీ పేరు మరియు _storage_data కలిపి ఉంటుంది. ఆ కమాండ్‌ను నమ్మే ముందు docker volume ls | grep storage_data తో నిర్ధారించుకోండి. ఎందుకంటే లేని వాల్యూమ్ పేరును ఇస్తే, Docker ఎర్రర్ చూపకుండా ఖాళీ వాల్యూమ్‌ను సృష్టిస్తుంది. దీనివల్ల ఎర్రర్ లేకుండానే ఖాళీ ఆర్కైవ్ తయారవుతుంది. ఆ తర్వాత ls -lh storage-*.tgz తో ఫైల్ పరిమాణాన్ని తనిఖీ చేయండి.

ఈ రెండు ఫైళ్లు ప్రస్తుతం అవి దేనిని రక్షిస్తున్నాయో అదే డిస్క్‌లో ఉన్నాయి, కాబట్టి ఇవి ఏ రకమైన రక్షణను ఇవ్వవు. వీటిని సర్వర్ నుండి బయటకు పంపి, ఎన్‌క్రిప్ట్ చేయండి. ఎందుకంటే డేటాబేస్ డంప్‌లో కస్టమర్ సందేశాలన్నీ ప్లెయిన్ టెక్స్ట్‌గా ఉంటాయి. restic తో ఎన్‌క్రిప్ట్ చేసిన ఆఫ్-సైట్ బ్యాకప్‌లు షెడ్యూలింగ్ మరియు రిటెన్షన్ గురించి వివరిస్తుంది.

రీస్టోర్ డ్రిల్, అవసరానికి ముందే ప్రయత్నించండి

లైవ్ సర్వర్‌పై కాకుండా, రెండవ VPSపై రీస్టోర్ చేయండి. .env, compose ఫైళ్లు మరియు రెండు ఆర్కైవ్‌లను కాపీ చేసి, ఇలా రన్ చేయండి:

docker compose up -d postgres
docker compose exec -T postgres pg_restore -U postgres -d chatwoot --clean --if-exists < db-2026-08-10.dump
docker run --rm -v chatwoot_storage_data:/data -v "$PWD":/backup alpine \
  sh -c 'rm -rf /data/* && tar xzf /backup/storage-2026-08-10.tgz -C /data'
docker compose up -d

--clean --if-exists డేటాను లోడ్ చేసే ముందు ఉన్న ఆబ్జెక్ట్‌లను తొలగిస్తుంది, కాబట్టి మీరు పోగొట్టుకోవడానికి సిద్ధంగా ఉన్న డేటాబేస్‌పై మాత్రమే దీనిని ఉపయోగించండి. ఆ తర్వాత లాగిన్ అయి, అటాచ్‌మెంట్ ఉన్న ఒక సంభాషణను తెరవండి. సందేశాల జాబితా లోడ్ అయ్యి, ఫైల్ డౌన్‌లోడ్ అయితే, మీ బ్యాకప్ సరైనదని అర్థం.

వేరొక SECRET_KEY_BASE తో రీస్టోర్ చేస్తే అన్ని సెషన్ కుక్కీలు చెల్లవు, కాబట్టి అందరూ లాగ్ అవుట్ అవుతారు. వేరొక ACTIVE_RECORD_ENCRYPTION_* కీలతో రీస్టోర్ చేయడం ఇంకా ప్రమాదకరం: Chatwoot ఛానల్ క్రెడెన్షియల్స్ ఉన్న కాలమ్స్‌ను డిక్రిప్ట్ చేయలేదు మరియు ActiveRecord::Encryption::Errors::Decryption ఎర్రర్‌ను చూపిస్తుంది. అందుకే .env బ్యాకప్ జాబితాలో ఉంది.

Chatwoot ను కొత్త tag కు upgrade చేయడం ఎలా

Commands కంటే వాటి క్రమం ముఖ్యమైనది.

  1. మీ tag మరియు target మధ్య ఉన్న release notes చదివి, అవసరమైన manual steps ఉన్నాయేమో పరిశీలించండి.
  2. తాజా database dump మరియు storage archive తీసుకుని, రెండు ఫైళ్ల పరిమాణాలు సహజంగా ఉన్నాయో తనిఖీ చేయండి.
  3. docker-compose.yaml లోని base service వద్ద image tag ను మార్చండి.
  4. కొత్త image ను pull చేసి, stack ను stop చేసి, migrations అమలు చేసి, తరువాత మళ్లీ start చేయండి.
docker compose pull
docker compose down
docker compose run --rm rails bundle exec rails db:chatwoot_prepare
docker compose up -d
docker compose images

Migration అమలు చేయడానికి ముందు image ను pull చేయండి. Migration కొత్త image నుంచే అమలు కావాలి; పాత image లో కొత్త migration files ఉండవు. Migration కు ముందు stack ను stop చేయండి. పాత code మరియు కొత్త schema పరస్పరం సరిపోవు. అందువల్ల నడుస్తున్న పాత Rails process errors ను సృష్టించవచ్చు లేదా కొత్త schema అంగీకరించని rows ను రాయవచ్చు. Stop చేయడం వల్ల migration కు అవసరమైన memory కూడా అందుబాటులోకి వస్తుంది. Upstream swap ను సూచించడానికి ఇదే కారణం.

ప్రతి container ప్రస్తుతం అమలు చేస్తున్న tag ను docker compose images చూపిస్తుంది. Tag మార్చి pull చేయడం మర్చిపోయిన పరిస్థితిని ఇది గుర్తిస్తుంది.

మీరు ఎంత దూరం వరకు jump చేయవచ్చో installation ఎంత పాతదో నిర్ణయిస్తుంది. ఒకటి లేదా రెండు releases వెనుకబడిన installation కోసం, మీ tag మరియు target మధ్య ఉన్న release notes ను పరిశీలించి, target tag ను సెట్ చేసి, పై steps ను ఒకసారి అమలు చేయండి. మీ installation చాలా పాతది అయితే మాత్రమే, latest image కు నేరుగా jump చేయకుండా intermediate image tags ద్వారా క్రమంగా upgrade చేయాలని upstream యొక్క Docker guide చెబుతుంది. అటువంటి సందర్భంలో ప్రతి intermediate tag కోసం tag మార్చడం, pull చేయడం, prepare step అమలు చేయడం పునరావృతం చేయండి. ఎందుకంటే ప్రతి upgrade తర్వాత db:chatwoot_prepare అమలు చేయాలని upstream సూచిస్తుంది.

Migration అమలు కాకముందే Rails ప్రారంభమైతే, అది requests ను అందించడానికి నిరాకరించి ActiveRecord::PendingMigrationError: Migrations are pending ను logs లో రాస్తుంది. restart: always సెట్ చేసి ఉంటే, container మళ్లీ మళ్లీ restart అవుతుంది. అందువల్ల docker compose ps ప్రతి కొన్ని సెకన్లకు reset అయ్యే uptime ను చూపిస్తుంది. Prepare step అమలు చేస్తే ఈ సమస్య తొలగిపోతుంది.

Rollback చేయాలంటే పాత tag ను మళ్లీ సెట్ చేసి, dump ను restore చేయండి. మీరు ఆధారపడగల reverse migration మార్గం లేదు. అందుకే step 2 అవసరం.

మీరు చూడబోయే వైఫల్య పరిస్థితులు మరియు సందేశాలు

Traefik నుంచి 502 Bad Gateway. Router సరిపోలింది, కానీ backend స్పందించలేదు. docker compose ps లో rails, Up గా కనిపిస్తుందో చూడండి. తరువాత docker network inspect proxy అమలు చేసి, container list లో rails container కనిపిస్తుందో నిర్ధారించండి. ఒక container ఏ networkకూ జత కాలేకపోతే Traefik దానికి చేరుకోలేడు. అందువల్ల అభ్యర్థన routerకు సరిపోతుంది, కానీ తరువాత ఎక్కడికీ వెళ్లదు.

Dashboard లోడ్ అవుతుంది, కానీ కొత్త సందేశాలను చూడటానికి refresh చేయాలి. /cable కు websocket కనెక్షన్ చేరడం లేదు, లేదా FRONTEND_URL browser barలోని addressతో సరిపోలడం లేదు. చిరునామాలు సరిపోలకపోతే, పేజీ వేరే originకు websocket తెరవడానికి ప్రయత్నిస్తుంది. దాన్ని browser నిరోధిస్తుంది.

FATAL: password authentication failed for user "postgres". .env లోని password మరియు Postgres data volumeలో ముందే నిల్వ చేసిన password వేర్వేరుగా ఉన్నాయి. నడుస్తున్న containerలో ALTER USER అమలు చేసి దాన్ని సరిచేయండి. ఇప్పటికే initialised అయిన databaseను .env మళ్లీ సవరించడం వల్ల మార్పు ఉండదు.

NOAUTH Authentication required. Redis, --requirepass తో నడుస్తోంది. కానీ application password లేకుండా కనెక్ట్ అయింది. అందువల్ల REDIS_PASSWORD, .env లో లేదు లేదా దాని విలువ చదవబడలేదు. Redis ఆశిస్తున్న passwordను docker compose exec redis sh -c 'redis-cli -a "$REDIS_PASSWORD" ping' తో నేరుగా పరీక్షించండి. అది PONG సమాధానం ఇవ్వాలి. Single quotes ముఖ్యమైనవి. అవి variableను మీ స్వంత shellలో కాకుండా containerలో expand చేస్తాయి. Container .env ను చదువుతుంది. మీ స్వంత shellలో ఆ variable సాధారణంగా ఖాళీగా ఉంటుంది.

Code 137తో Containers నిష్క్రమించడం. అది SIGKILL. తక్కువ సామర్థ్యం ఉన్న serverలో సాధారణంగా ఈ signalను kernel యొక్క out of memory killer పంపుతుంది. అయితే docker kill కూడా అదే signalను పంపుతుంది. కాబట్టి memory సమస్య అని నిర్ధారించకముందు sudo dmesg -T | grep -i "killed process" ను పరిశీలించండి. Memory సమస్య అయితే swap జోడించండి, ప్రతి serviceకు memory limits సెట్ చేయండి లేదా పెద్ద planకు మారండి.

FAQ

self-hosted Chatwoot VPS కు ఎంత RAM అవసరం?

October 2026 నాటికి, upstream కనీసంగా 4 GB RAM మరియు 4 CPU cores ను అడుగుతోంది. ఈ పరిమాణం రోజుకు గరిష్ఠంగా 10,000 conversations వరకు సరిపోతుందని పేర్కొంది. 20,000 conversations వరకు కోసం 8 GB RAM మరియు 8 cores అవసరం. కనీసం 1 GB swap జోడించండి. Upgrade సమయంలో migrations అమలు చేయడానికి మరో Rails process ప్రారంభమవుతుంది. చిన్న VPS లలో memory అయిపోవడానికి ఇదే కారణం. 2 GB VPS ప్రారంభమై, ఇద్దరు agents కోసం పనిచేయగలదు. అయితే load సమయంలో Sidekiq ఒక్కటే 1 GB కంటే ఎక్కువ memory ఉపయోగించవచ్చు. కాబట్టి busy periods లో మరియు upgrades సమయంలో containers exit code 137 తో నిలిపివేయబడవచ్చని భావించండి.

Chatwoot password reset emails ఎందుకు ఎప్పుడూ రావు?

ఎందుకంటే SMTP_ADDRESS సెట్ కాలేదు. అందువల్ల Chatwoot sendmail delivery కు fallback అవుతుంది. upstream ఉద్దేశించిన విధంగా ఇది host పై Postfix server install అయి ఉన్నప్పుడు పనిచేస్తుంది. ఈ Docker setup లో అలాంటి server లేదు. Job Sidekiq లో నడుస్తుంది. అందువల్ల delivery error Sidekiq log లో కనిపిస్తుంది, కానీ browser మాత్రం success message చూపిస్తుంది. SMTP_ADDRESS, SMTP_PORT, SMTP_USERNAME, SMTP_PASSWORD మరియు MAILER_SENDER_EMAIL ను .env లో సెట్ చేసి, rails మరియు sidekiq services ను restart చేయండి. తరువాత మీరు reset ను trigger చేస్తున్నప్పుడు docker compose logs -f sidekiq ను monitor చేయండి.

Chatwoot ను restore చేయడానికి ఏవి backup చేయాలి?

Postgres database, storage_data Docker volume, .env file మరియు compose files ను backup చేయాలి. Database మాత్రమే సరిపోదు. Uploaded files volume లో ఉంటాయి, Postgres వాటి references ను మాత్రమే ఉంచుతుంది. అందువల్ల database-only restore చేసినప్పుడు attachments పనిచేయని conversations లభిస్తాయి. .env ముఖ్యమైనది. వేరే SECRET_KEY_BASE ప్రతి user ను sign out చేస్తుంది. అలాగే వేరే ACTIVE_RECORD_ENCRYPTION_* keys encrypted columns ను చదవలేనివిగా చేస్తాయి.

Database ను పాడుచేయకుండా Chatwoot ను ఎలా upgrade చేయాలి?

ముందుగా backup తీసుకోండి. మీ tag మరియు target మధ్య ఉన్న release notes చదవండి. మీ compose file లో image tag ను మార్చండి. తరువాత docker compose pull, docker compose down, docker compose run --rm rails bundle exec rails db:chatwoot_prepare మరియు docker compose up -d అమలు చేయండి. ముందుగా image ను pull చేయండి. Migrations కొత్త image నుంచే అమలు కావాలి. Stack ను ముందుగా stop చేయండి. కొత్త schema పై పాత code పనిచేస్తే errors వస్తాయి. చాలా పాత install మాత్రమే intermediate image tags ద్వారా దశలవారీగా వెళ్లాలి. అటువంటి install లో latest కు నేరుగా వెళ్లకుండా, ప్రతి intermediate tag తర్వాత prepare step అమలు చేయాలి.

pgvector బదులుగా standard postgres image ను ఉపయోగించవచ్చా?

లేదు. Chatwoot schema vector extension ను enable చేస్తుంది. అందువల్ల stock postgres image లో db:chatwoot_prepare సమయంలో ERROR: extension "vector" is not available తో failure వస్తుంది. ఆ image లో extension control file ఉండదు. upstream compose file లోని pgvector/pgvector:pg16 ను అలాగే ఉంచండి. లేదా మీ Postgres major version కోసం pgvector ను ship చేసే మరొక image ను ఉపయోగించండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#chatwoot#self-hosting#docker-compose#support-desk#smtp#backups