# Dify Docker Compose ve HTTPS ile nasıl barındırılır

> Dify'ı Ubuntu veya Debian üzerinde Docker Compose ile kurun: varsayılan gizli değerleri değiştirin, Nginx'i Caddy HTTPS arkasında tutun, Ollama'yı bağlayın.

Zorluk: Orta\
Denendiği sistemler: Ubuntu 24.04 LTS, Ubuntu 26.04 LTS, Debian 12, Debian 13

Dify, büyük dil modelleri üzerine uygulama geliştirmek için açık kaynaklı bir platformdur: sohbet botları, ajanlar, bilgi tabanlı erişim (RAG) ve görsel iş akışları; her birinin kendi API'si vardır. Resmi self-hosting yöntemi, projenin deposundan Docker Compose ile kurulumdur. Varsayılan yığın API'yi, arka plan işçilerini, web arayüzünü, bir eklenti servisini (plugin daemon), bir kod sandbox'ını, bir ajan arka ucunu, PostgreSQL'i, Redis'i, Weaviate vektör veritabanını ve bir Nginx ağ geçidini çalıştırır.

Bu rehber bir Dify sürümünü `/opt/dify` içine klonlar, ilk başlatmadan önce tüm varsayılan parola ve anahtarları değiştirir, paketle gelen Nginx'i HTTPS için Caddy arkasında bir localhost portunda tutar, ilk kurulum yönetici sayfasını bir başlangıç parolasıyla korur ve Ollama'yı bağlar. Yedekleme ve yükseltme düzeniyle biter.

## Ön koşullar

- **Ubuntu 24.04 LTS**, **Ubuntu 26.04 LTS**, **Debian 12** veya **Debian 13** çalıştıran bir sunucu. Dify belgeleri Docker 19.03 veya üzeri ve **Docker Compose 2.24.0 veya üzeri** ile Linux'u destekler; ikisini de [Ubuntu'ya Docker kurulumu](/guides/install-docker-ubuntu) veya [Debian'a Docker kurulumu](/guides/install-docker-debian) rehberiyle kurun.
- `sudo` yetkisi ve SSH anahtarıyla girişi olan, root olmayan bir kullanıcı; bkz. [Yeni bir Linux sunucusunu güvenli hale getirin](/guides/secure-a-new-linux-server) ve [SSH anahtarlarını ayarlayın](/guides/ssh-keys).
- Sunucuyu gösteren bir A (isteğe bağlı olarak AAAA) kaydına sahip `dify.example.com` gibi bir alan adı ve [Caddy reverse proxy](/guides/caddy-reverse-proxy) rehberindeki Caddy kurulumu.
- Bir model sağlayıcı hesabı (OpenAI, Anthropic ve diğerleri) veya [Ollama kurulumu](/guides/install-ollama) ile kurulmuş Ollama.

| Kaynak | En düşük (resmi) | Önerilen başlangıç |
|---|---|---|
| CPU | 2 çekirdek | 4 vCPU |
| RAM | 4 GiB | 8 GB |
| Disk | Yayınlanmamış | İmajlar, yüklemeler ve vektör verileri için 40 GB veya daha fazla |

Önerilen sütun ihtiyatlı bir başlangıç noktasıdır, ölçüm sonucu değildir. Devam etmeden önce Compose sürümünüzü doğrulayın:

```bash
docker compose version
```

## Adım 1 — Bir Dify sürümünü klonlayın

Dify belgeleri geliştirme dalını değil, en son **sürüm etiketini** klonlar. Komut en yeni etiketi GitHub API'sinden ister; bu nedenle `curl` ve `jq` gerekir. `python3` ise Adım 2'de iki belirteç üretmek için kullanılır.

```bash
sudo apt update
sudo apt install git curl jq openssl python3
sudo mkdir -p /opt/dify
sudo chown $USER:$USER /opt/dify
git clone --branch "$(curl -s https://api.github.com/repos/langgenius/dify/releases/latest | jq -r .tag_name)" https://github.com/langgenius/dify.git /opt/dify
cd /opt/dify
git describe --tags
```

`git describe --tags` klonladığınız sürümü yazar, örneğin `1.17.1`. Klonlama `Remote branch null not found` hatasıyla başarısız olursa API çağrısı bir etiket döndürmemiştir; [sürümler sayfasından](https://github.com/langgenius/dify/releases) güncel sürümü seçin ve bunun yerine o etiketle `git clone --branch 1.17.1 https://github.com/langgenius/dify.git /opt/dify` çalıştırın.

## Adım 2 — .env dosyasını oluşturun ve varsayılan gizli değerleri değiştirin

Yapılandırdığınız her şey `.env.example` dosyasından oluşturulan `/opt/dify/docker/.env` dosyasındadır. İsteğe bağlı, sağlayıcıya özgü ayarların `docker/envs/` altında kendi şablonları vardır; `.env` içindeki değerler onlardan önceliklidir.

```bash
cd /opt/dify/docker
cp .env.example .env
chmod 600 .env
```

Örnek dosya herkesçe bilinen varsayılanlarla gelir: PostgreSQL ve Redis için `difyai123456`, sandbox, Weaviate ve eklenti servisi için sabit anahtarlar gibi. Bunları rastgele değerlerle değiştirin. Bazı çiftlerin eşleşmesi gerekir; komutun aynı kabuk değişkenini yeniden kullanmasının nedeni budur: `REDIS_PASSWORD` aynı zamanda `CELERY_BROKER_URL` içinde geçer, `SANDBOX_API_KEY` değeri `CODE_EXECUTION_API_KEY` ile aynı olmalıdır ve Weaviate anahtarı iki yerde bulunur.

```bash
DB_PW=$(openssl rand -hex 24)
REDIS_PW=$(openssl rand -hex 24)
SANDBOX_KEY=$(openssl rand -hex 24)
WEAVIATE_KEY=$(openssl rand -hex 24)
sed -i \
  -e "s|^SECRET_KEY=.*|SECRET_KEY=$(openssl rand -base64 42)|" \
  -e "s|^INIT_PASSWORD=.*|INIT_PASSWORD=$(openssl rand -hex 12)|" \
  -e "s|^DB_PASSWORD=.*|DB_PASSWORD=${DB_PW}|" \
  -e "s|^REDIS_PASSWORD=.*|REDIS_PASSWORD=${REDIS_PW}|" \
  -e "s|^CELERY_BROKER_URL=.*|CELERY_BROKER_URL=redis://:${REDIS_PW}@redis:6379/1|" \
  -e "s|^CODE_EXECUTION_API_KEY=.*|CODE_EXECUTION_API_KEY=${SANDBOX_KEY}|" \
  -e "s|^SANDBOX_API_KEY=.*|SANDBOX_API_KEY=${SANDBOX_KEY}|" \
  -e "s|^WEAVIATE_API_KEY=.*|WEAVIATE_API_KEY=${WEAVIATE_KEY}|" \
  -e "s|^WEAVIATE_AUTHENTICATION_APIKEY_ALLOWED_KEYS=.*|WEAVIATE_AUTHENTICATION_APIKEY_ALLOWED_KEYS=${WEAVIATE_KEY}|" \
  -e "s|^PLUGIN_DAEMON_KEY=.*|PLUGIN_DAEMON_KEY=$(openssl rand -hex 32)|" \
  -e "s|^PLUGIN_DIFY_INNER_API_KEY=.*|PLUGIN_DIFY_INNER_API_KEY=$(openssl rand -hex 32)|" \
  -e "s|^DIFY_AGENT_API_TOKEN=.*|DIFY_AGENT_API_TOKEN=$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')|" \
  -e "s|^DIFY_AGENT_SERVER_SECRET_KEY=.*|DIFY_AGENT_SERVER_SECRET_KEY=$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')|" \
  .env
```

`SECRET_KEY` oturumları, belirteçleri ve dosya adreslerini imzalar; belgeler onu `openssl rand -base64 42` ile üretir. `INIT_PASSWORD` (en fazla 30 karakter), yönetici hesabını oluşturana kadar `/install` sayfasını korur. İki `DIFY_AGENT_*` değeri, ajan arka ucunun geliştirme varsayılanlarının yerini alır ve örnek dosyanın önerdiği şekilde üretilir.

> **Uyarı**
>
> Bu değerleri ilk `docker compose up` komutundan önce ayarlayın. PostgreSQL ve Redis parolalarını veri dizinleri oluşturulurken kaydeder; bu yüzden `DB_PASSWORD` veya `REDIS_PASSWORD` değerini sonradan yalnızca `.env` içinde değiştirmek bağlantıyı bozar.

Ardından Dify'a herkese açık adresini bildirin ve yayınlanan tüm portları localhost'a taşıyın. Compose dosyası Nginx'i `EXPOSE_NGINX_PORT:80` ve `EXPOSE_NGINX_SSL_PORT:443` olarak, eklenti servisinin uzaktan hata ayıklama portunu da `EXPOSE_PLUGIN_DEBUGGING_PORT` olarak eşler. Ana makine portunun önüne `127.0.0.1:` yazmak bu portları internetten uzak tutar ve 80 ile 443 numaralı portları Caddy'ye bırakır.

```bash
DIFY_URL=https://dify.example.com
sed -i \
  -e "s|^CONSOLE_API_URL=.*|CONSOLE_API_URL=${DIFY_URL}|" \
  -e "s|^CONSOLE_WEB_URL=.*|CONSOLE_WEB_URL=${DIFY_URL}|" \
  -e "s|^SERVICE_API_URL=.*|SERVICE_API_URL=${DIFY_URL}|" \
  -e "s|^APP_API_URL=.*|APP_API_URL=${DIFY_URL}|" \
  -e "s|^APP_WEB_URL=.*|APP_WEB_URL=${DIFY_URL}|" \
  -e "s|^FILES_URL=.*|FILES_URL=${DIFY_URL}|" \
  -e "s|^TRIGGER_URL=.*|TRIGGER_URL=${DIFY_URL}|" \
  -e "s|^ENDPOINT_URL_TEMPLATE=.*|ENDPOINT_URL_TEMPLATE=${DIFY_URL}/e/{hook_id}|" \
  -e "s|^NEXT_PUBLIC_SOCKET_URL=.*|NEXT_PUBLIC_SOCKET_URL=wss://dify.example.com|" \
  -e "s|^EXPOSE_NGINX_PORT=.*|EXPOSE_NGINX_PORT=127.0.0.1:8080|" \
  -e "s|^EXPOSE_NGINX_SSL_PORT=.*|EXPOSE_NGINX_SSL_PORT=127.0.0.1:8443|" \
  -e "s|^EXPOSE_PLUGIN_DEBUGGING_PORT=.*|EXPOSE_PLUGIN_DEBUGGING_PORT=127.0.0.1:5003|" \
  .env
grep -E '^(INIT_PASSWORD|DB_PASSWORD|CONSOLE_WEB_URL|EXPOSE_NGINX_PORT|EXPOSE_NGINX_SSL_PORT)=' .env
```

Adres ayarları bir proxy arkasında önemlidir: `CONSOLE_API_URL` Dify'ın yalnızca HTTPS çerezleri verip vermeyeceğini de belirler, `FILES_URL` dosya önizleme bağlantılarını, `TRIGGER_URL` webhook geri çağrılarını oluşturur, `NEXT_PUBLIC_SOCKET_URL` ise iş akışı tuvalindeki gerçek zamanlı ortak çalışma için WebSocket adresidir. `grep` çıktısındaki `INIT_PASSWORD` değerini not edin; Adım 5'te gerekecek. `ALLOW_REGISTER` varsayılan olarak `false` olduğu için kayıt kapalı kalır; yeni üyeler yalnızca davetle katılır.

## Adım 3 — Yığını başlatın

```bash
docker compose up -d
docker compose ps
```

İlk başlatma bir düzine imajı çeker ve birkaç dakika sürer. `docker compose ps` çıktısında servisler `Up` veya `healthy` görünmelidir; `init_permissions` tek seferlik bir görevdir ve `Exited` görünmesi beklenen durumdur. `nginx` satırında `127.0.0.1:8080->80/tcp` ve `127.0.0.1:8443->443/tcp` görünmeli, hiçbir port `0.0.0.0` adresine bağlı olmamalıdır. Ağ geçidinin yerelde yanıt verdiğini kontrol edin:

```bash
curl -I http://127.0.0.1:8080/install
```

Herhangi bir HTTP durum satırı (genellikle `200`), Nginx'in, web arayüzünün ve API'nin birbiriyle konuştuğunu gösterir.

## Adım 4 — Dify'ı Caddy ile HTTPS üzerinden yayınlayın

`/etc/caddy/Caddyfile` dosyasına paketle gelen Nginx'e yönlendiren bir site bloğu ekleyin:

```caddyfile
dify.example.com {
    reverse_proxy 127.0.0.1:8080
}
```

Caddy'yi yeniden yükleyin ve ufw üzerinden yalnızca SSH ve web trafiğine izin verin:

```bash
sudo systemctl reload caddy
sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
curl -I https://dify.example.com/install
```

Caddy özgün `Host` başlığını iletir, ortak çalışma kanalı için WebSocket yükseltmelerini kendiliğinden aktarır ve akış halindeki yanıtları hemen gönderir; böylece sohbet yanıtları parça parça görünür. Caddy TLS'i sonlandırdığı için Dify'ın Nginx içindeki kendi HTTPS desteği (`NGINX_HTTPS_ENABLED`) kapalı kalır. Alternatif olarak Nginx ve Certbot ([rehber](/guides/nginx-reverse-proxy-certbot)) veya [Traefik](/guides/traefik-reverse-proxy) kullanılabilir; Nginx kullanırsanız `/socket.io/` yolunda `Upgrade` ve `Connection` başlıklarını iletin.

## Adım 5 — Yönetici hesabını oluşturun

`https://dify.example.com/install` adresini açın. Dify önce Adım 2'deki başlangıç parolasını, ardından yöneticinin e-posta adresini, adını ve parolasını ister. Uzun ve benzersiz bir parola kullanın. Sonrasında stüdyoya geçersiniz ve başlangıç parolasının artık bir etkisi kalmaz.

Kaydı açmak yerine çalışma arkadaşlarınızı çalışma alanının üye ayarlarından davet edin. Model sağlayıcılarını yalnızca çalışma alanı sahibi ve yöneticiler yönetebilir.

Dify, e-posta `.env` içinde yapılandırıldığında hesap davetlerini, parola sıfırlamalarını ve giriş kodlarını e-postayla gönderir: STARTTLS için `MAIL_TYPE=smtp`, `MAIL_DEFAULT_SEND_FROM`, `SMTP_SERVER=smtp.example.com`, `SMTP_PORT=587`, `SMTP_USERNAME`, `SMTP_PASSWORD`, `SMTP_USE_TLS=true` ve `SMTP_OPPORTUNISTIC_TLS=true` değerlerini ayarlayın, ardından `docker compose up -d` çalıştırın.

> **Not**
>
> HyperDC VPS'lerde giden 25 numaralı port varsayılan olarak kapalıdır. 3 ay veya daha uzun süreyle satın alınan hizmetlerde talep üzerine açılır: [destek talebi açın](/guides/support-tickets). O zamana kadar e-postaları 587 numaralı port üzerinden bir SMTP relay ile gönderin.

## Adım 6 — Ollama dahil model sağlayıcılarını bağlayın

Dify 1.x'te her model sağlayıcısı bir eklentidir. **Integrations**, ardından **Model Provider** bölümünü açın, ihtiyacınız olan sağlayıcıları Marketplace'ten kurun ve API anahtarlarını girmek için **Setup** düğmesine tıklayın. Dify her anahtarı kaydetmeden önce doğrular. Eklenti servisi eklentileri `marketplace.dify.ai` adresinden indirir ve imzalarını varsayılan olarak doğrular (`FORCE_VERIFYING_SIGNATURE=true`); bu yüzden giden HTTPS trafiğini açık tutun.

Aynı sunucudaki Ollama için üç şey gerekir. İlk olarak Ollama'nın `127.0.0.1` dışında da dinlemesi gerekir; Ollama SSS sayfası bunu `OLLAMA_HOST` ile yapar:

```bash
sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo tee /etc/systemd/system/ollama.service.d/override.conf <<'EOF'
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
EOF
sudo systemctl daemon-reload
sudo systemctl restart ollama
```

> **Uyarı**
>
> Ollama'nın kimlik doğrulaması yoktur. ufw'yi varsayılan reddetme politikasıyla açık tutun ve yalnızca aşağıdaki Docker alt ağına izin verin; 11434 numaralı portu asla herkese açmayın.

İkinci olarak ufw'nin Dify ağının ana makineye ulaşmasına izin vermesi gerekir. Compose projesi `docker` klasörünün adını alır, bu yüzden ağın adı `docker_default` olur. Üçüncü olarak Dify'ın Compose dosyası `host.docker.internal` takma adını tanımlamaz; ana makinenin Docker köprü adresini, genellikle `172.17.0.1` değerini kullanın:

```bash
docker network inspect docker_default | grep Subnet
sudo ufw allow from 172.19.0.0/16 to any port 11434 proto tcp
ip -4 addr show docker0
curl http://172.17.0.1:11434/api/version
```

`172.19.0.0/16` değerini ilk komutun yazdığı alt ağla, farklıysa `172.17.0.1` değerini de `docker0` arayüzünün `inet` adresiyle değiştirin. Bu kural Ollama'yı yalnızca ufw varsayılan reddetme politikasıyla etkinken korur; `sudo ufw status verbose` çıktısında `Status: active` ve `deny (incoming)` göründüğünü ve başka bir makineden `nc -vz sunucu-ip-adresiniz 11434` komutunun başarısız olduğunu doğrulayın. Son komut Ollama'nın sürümünü JSON olarak döndürmelidir. Ardından Dify'da **Ollama** eklentisini kurun, `ollama list` çıktısındaki adı birebir kullanarak bir model ekleyin ve temel adresi `http://172.17.0.1:11434` olarak girin. Büyük modellerde bir [GPU sunucusu](/gpu-servers) büyük fark yaratır.

## Yedekleme ve geri yükleme

Dify durumunu `/opt/dify/docker/volumes` içinde (PostgreSQL verileri, `app/storage` içindeki yüklenen dosyalar, Weaviate vektörleri, Redis verileri, eklenti depolaması), yapılandırmasını ise `.env` içinde tutar. Yığın çalışırken mantıksal bir veritabanı dökümü alın, ardından dosyaları tutarlı şekilde arşivlemek için yığını kısa süreliğine durdurun:

```bash
sudo mkdir -p /opt/backups
sudo chown $USER:$USER /opt/backups
cd /opt/dify/docker
docker compose exec -T db_postgres pg_dumpall -U postgres | gzip > /opt/backups/dify-db-$(date +%F).sql.gz
docker compose stop
sudo tar czf /opt/backups/dify-files-$(date +%F).tar.gz -C /opt/dify/docker volumes .env
docker compose start
```

`pg_dumpall` hem `dify` veritabanını hem de eklenti servisinin `dify_plugin` veritabanını alır. Yeni bir sunucuya geri yüklemek için Adım 1'dekiyle **aynı** sürüm etiketini klonlayın, dosya arşivini `docker` klasörüne açın ve yığını başlatın:

```bash
cd /opt/dify/docker
sudo tar xzf /opt/backups/dify-files-2026-10-09.tar.gz -C /opt/dify/docker
docker compose up -d
```

SQL dökümü ikinci savunma hattınızdır: veri dizininin kendisi bozulduysa `gunzip -c dify-db-2026-10-09.sql.gz | docker compose exec -T db_postgres psql -U postgres` ile boş bir PostgreSQL'e yükleyin. İki arşivi de sunucunun dışına kopyalayın; gizli değerlerinizi içerirler.

## Dify güncelleme

Dify'ın yükseltme notları sürümden sürüme değişebilir; bu yüzden önce mevcut sürümünüzle hedef sürüm arasındaki her sürümün [sürüm notlarını](https://github.com/langgenius/dify/releases) okuyun.

> **Tehlike**
>
> Bazı sürümler ek adımlar gerektirir. Örneğin Dify 1.17.1, yeni sürüm başlamadan önce paketle gelen Weaviate için aşamalı, elle yapılan bir yükseltme ister; doğrudan çekip yeniden başlatmak vektör aramasını kalıcı olarak bozabilir. Her zaman önce tam bir kopya alın.

Sürüm notlarındaki olağan Docker Compose yöntemi, tam yedek kopya ve ortam değişkeni eşitleme betiği eklenmiş haliyle:

```bash
cd /opt/dify/docker
docker compose down
sudo cp -a /opt/dify /opt/backups/dify-$(date +%F)
git fetch --tags
git checkout 1.17.1
chmod +x dify-env-sync.sh
./dify-env-sync.sh
docker compose pull
docker compose up -d
```

`1.17.1` değerini hedef etiketle değiştirin. `cp -a` sahiplikleri korur; böylece kopya olduğu gibi geri yüklenebilir. `dify-env-sync.sh`, `.env.example` içindeki yeni değişkenleri sizin değerlerinizin üzerine yazmadan `.env` dosyanıza ekler ve eski dosyayı önce `env-backup/` içine kaydeder. Veritabanı geçişleri API başlarken kendiliğinden çalışır; `docker compose logs -f api` ile izleyin.

## Sorun giderme

### Port 80 veya 443 zaten kullanımda

Ana makinede 80 ve 443 numaralı portlar Caddy'ye aittir. `docker compose up` komutu `address already in use` hatasıyla başarısız olursa `.env` içindeki `EXPOSE_NGINX_PORT` veya `EXPOSE_NGINX_SSL_PORT` satırları değiştirilmemiştir. Adım 2'deki gibi düzeltin ve `docker compose up -d` komutunu yeniden çalıştırın.

### fatal: Remote branch null not found in upstream origin

GitHub API çağrısı, çoğunlukla istek sınırlaması nedeniyle bir etiket döndürmedi. Adım 1'de gösterildiği gibi sürümler sayfasındaki bir etiketi açıkça belirterek klonlayın.

### Yeniden başlatmadan sonra 502 Bad Gateway

`docker compose ps` çıktısını kontrol edin: her servis `Up` veya `healthy` olmalıdır. Dify belgelerine göre paketle gelen Nginx, konteynerler yeniden başladıktan sonra eski konteyner adreslerine yönlendirmeye devam edebilir. Ağ geçidini `docker compose restart nginx` ile yeniden başlatın; sunucu yeniden başlatıldıktan sonra `docker compose down` ve `docker compose up -d` çalıştırın.

### Sayfa sonsuza kadar yükleniyor veya konsolda CORS hataları görünüyor

`.env` içindeki adres değişkenleri tarayıcınızdaki adresle eşleşmiyor. `CONSOLE_API_URL`, `CONSOLE_WEB_URL`, `SERVICE_API_URL`, `APP_API_URL`, `APP_WEB_URL` ve `FILES_URL` değerlerini düzeltin, ardından `docker compose down` ve `docker compose up -d` çalıştırın.

### HTTP Request düğümü dahili bir adrese ulaşamıyor

Bu tasarım gereğidir: Dify, HTTP düğümlerinden giden istekleri dahili ve özel adres aralıklarını engelleyen `ssrf_proxy` üzerinden yönlendirir. Yalnızca tüm iş akışı yazarlarına güveniyorsanız belgelerde anlatıldığı gibi `docker/volumes/ssrf_proxy/squid.conf` dosyasına ACL kuralları ekleyin ve proxy konteynerini yeniden başlatın.

## Sonraki adımlar

- Yerel modelleri [Ollama kurulumu](/guides/install-ollama) ile çalıştırın ve Adım 6'daki gibi bağlayın.
- Görsel ve koda yakın bir alternatif için [Langflow kurulumu](/guides/install-langflow) rehberine bakın.
- Depolama veya vektör veritabanı ayarlarını değiştirmeden önce resmi [Dify ortam değişkenleri başvurusunu](https://docs.dify.ai/en/self-host/deploy/configuration/environments) okuyun.
- Bu uygulama için sunucu seçeneklerini [Dify hosting](/dify-hosting) sayfasında inceleyin.

## Sık sorulan sorular

### Dify ne kadar belleğe ihtiyaç duyar?

Dify belgeleri en az 2 CPU çekirdeği ve 4 GiB RAM ister. Varsayılan yığın PostgreSQL, Redis ve Weaviate dahil ondan fazla konteyner başlatır; 8 GB rahat çalışma alanı bırakır. Yerel modellerin kendi bellek ihtiyacı buna eklenir.

### Dify hesabının unutulan parolasını nasıl sıfırlarım?

/opt/dify/docker içinde docker compose exec api flask reset-password komutunu çalıştırın. Komut hesabın e-posta adresini ve yeni parolayı sorar; bu yüzden bir posta sunucusu yapılandırılmamış olsa da çalışır.

### Kurulum sayfası neden parola istiyor?

Bu rehber .env içinde INIT_PASSWORD ayarlar. Dify bu durumda yönetici hesabı oluşturulmadan önce /install sayfasında bu parolayı ister; böylece HTTPS üzerinden zaten erişilebilen yeni bir sunucu korunur. Kurulumdan sonra bu değerin başka bir etkisi kalmaz.

### Veritabanı parolasını daha sonra .env dosyasını düzenleyerek değiştirebilir miyim?

Yalnızca .env dosyasını düzenleyerek değiştiremezsiniz. PostgreSQL parolayı veritabanı ilk oluşturulduğunda kendi veri dizinine kaydeder; yeni bir DB_PASSWORD artık eşleşmez. Güçlü değerleri ilk başlatmadan önce ayarlayın veya parolayı PostgreSQL içinde de değiştirin.

### Dify, Ollama'da çalışan modelleri kullanabilir mi?

Evet. Dify Marketplace'ten Ollama sağlayıcı eklentisini kurun, Ollama'yı Docker ağlarından erişilebilir yapın ve temel adres olarak Docker köprü adresini, genellikle http://172.17.0.1:11434 değerini kullanın.

---

Kaynak: <https://hyperdc.com/tr/guides/tutorials/install-dify>\
Son güncelleme: 2026-10-09