# İş birliği sunucusu çalıştırma

Oleafly Server'ın ne sakladığı, neye ihtiyaç duyduğu, tek komutla nasıl kurulduğu ya da Docker Compose, Coolify, Render, Railway ya da düz bir Linux servisiyle nasıl çalıştırıldığı ve son olarak ilk yönetici olma.

Oleafly Server, canlı iş birliğinin arkasındaki iş birliği sunucusudur. Laboratuvarınız, bölümünüz ya da kurumunuz onu kendi makinelerinde ya da kendi bulut hesabında çalıştırır. Kişiler onu Oleafly'de ekler ve GitHub ya da üniversite oturumu gibi zaten sahip oldukları bir hesapla oturum açar. Biri bir projeyi sunucuda paylaştığında, eklediği kişiler düzenlerken eşitlenmeye devam eden tam bir kopya alır. [Tarayıcı erişimi](/docs/collaboration/server-access/#browser-access) açıkken projeyi bir web tarayıcısında da açabilirler.

Bu kılavuz, bir laboratuvar, ders ya da ortak yazar grubu için sunucuyu çalıştıran kişi içindir. Bir terminalle rahatça çalışabiliyor olmalısınız. Bazı kurulumlar ayrıca bir yapılandırma dosyasını düzenlemenizi ister. Kod yazmanız gerekmez.

Güvenlik incelemeniz için [Sunucu güvenliği](/security/) sayfasını okuyun. Kendi sunucunuzda barındırmayı, oturum açmayı, cihaz anahtarlarını, imzalı değişiklikleri, güvenlik ve erişim günlüklerini ve yazılım malzeme listesiyle birlikte kapsayıcı imajını kapsar.

## Sunucunun sakladıkları

Sunucu her şeyi, `OLEAFLY_DATA_DIR` ile ayarlanan tek bir veri klasöründe tutar:

- **Hesaplar**: her üyenin görünen adı, avatar adresi, doğrulanmış e-posta adresleri ile kullanıcı kimliği ve oturum açma sağlayıcısındaki oturum açma bilgisi. Sunucu hiçbir zaman bir parola görmez ya da saklamaz.
- **Cihazlar**: oturum açmış her bilgisayar; adı, işletim sistemi, açık anahtarı ve son ne zaman görüldüğüyle birlikte. Oturum açma belirteçleri yalnızca karma olarak saklanır.
- **Güvenlik günlüğü**: oturum açmalar ve reddedilen oturum açmalar, eklenen ve oturumu kapatılan cihazlar, üyelerde, rollerde ve ayarlardaki değişiklikler, paylaşılan, arşivlenen ve geri yüklenen projeler, bir projeyi kimin açabileceğine dair değişiklikler ve konuk davetleri. Her girdinin saati ve IP adresi vardır.
- Yöneticilerin Oleafly'de değiştirdiği **sunucu ayarları**.
- **Proje erişim günlükleri**, yalnızca sahibi bunu açan projeler için: projeyi kimin açtığı, katıldığı ya da kopyasını indirdiği; cihaz adı ve saatle birlikte. Yalnızca projenin sahibi okuyabilir.
- **Konuk davetleri**: davet edilen e-posta adresi, proje, rol ve gönderen.
- **Paylaşılan projeler**: her dosya ve değişikliklerin tüm geçmişi; bunlara ait yorumlar, öneriler, sohbet ve sürüm adlarıyla birlikte.
- **Derlenmiş PDF'ler**: paylaşılan her proje için, bir sahibin ya da düzenleyenin uygulamasının başarılı bir derlemeden sonra gönderdiği en yeni PDF ve SyncTeX dosyası; kimin ne zaman derlediğiyle birlikte.

Güvenlik günlüğü ve erişim günlüklerindeki girdiler ile yanıtlanmış ya da süresi geçmiş konuk davetleri, varsayılan olarak 365 gün olan `OLEAFLY_SECURITY_LOG_DAYS` gününden sonra silinir. Bir projenin artık kullanmadığı dosyalar, örneğin değiştirilen bir şeklin eski kopyası, projenin onları son kullanmasından 30 gün sonra silinir. Derlenen her PDF bir öncekinin yerini alır. Bir sahip paylaşmayı bıraktığında sunucu, projeyi varsayılan olarak 30 gün olan `OLEAFLY_ARCHIVE_DAYS` gün boyunca salt okunur tutar ve sonra siler. O süre içinde yalnızca sahip ve projedeki yöneticiler indirebilir.

### Projeleri kimler okuyabilir

Projeler sunucuda şifreli değildir. Veri klasörünü, makinenin diskini ya da yedeklerinizi okuyabilen herkes, orada saklanan her projeyi okuyabilir. Buna makineyi çalıştıran kişiler ve onu barındıran şirket dahildir.

Oleafly içinde kurallar daha sıkıdır. Hiçbir sunucu rolü, yönetici dahil, projenin sahibi kendisini eklemedikçe bir projeyi açamaz. Bir projenin sunucuyu çalıştıran kişilerden uzak durması gerekiyorsa, onun için ayrı bir sunucu çalıştırın.

Her üyenin bilgisayarı da kendisiyle paylaşılan her projenin tam bir kopyasını tutar. Üyelerden disk şifrelemesini açmalarını isteyin; örneğin macOS'ta FileVault, Windows'ta BitLocker, Linux'ta LUKS.

## Neye ihtiyacınız var

- **Sürekli açık bir makine.** Herhangi bir Linux makinesi çalışır; Render ya da Railway gibi bir barındırma hizmeti hesabı da olur. Başlamak için küçük bir sanal makine yeterlidir. Projeler büyüdükçe belleğini ve diskini izleyin. Sunucu x86-64 ve ARM üzerinde çalışır.
- **Sunucu için bir alan adı**, örneğin `collab.example.org`, makineye işaret eden bir DNS kaydıyla birlikte. Render ve Railway, elinizde yoksa size bir adres verir. Makinenin genel adresi yoksa [Genel adres olmadan](#without-a-public-address) bölümünü okuyun.
- **Kişilerin oturum açma yolu**: en az bir oturum açma sağlayıcısı, örneğin bir GitHub OAuth uygulaması ya da kurumunuzun oturum açması. Sağlayıcı olmadan sunucu başlamaz. Sunucunun e-posta gönderebileceği bir e-posta hesabı isteğe bağlıdır. O varsa bir yönetici, kişilerin e-postayla gönderilen bir bağlantıyla da oturum açmasına izin verebilir. [Oturum açma ve erişim](/docs/collaboration/server-access/) bölümünü okuyun.

Her sürüm, `ghcr.io/oleafly/oleafly-server` kapsayıcı imajı olarak yayımlanır. Yükleyici ve Compose dosyaları [Oleafly Server sürümleri sayfasındadır](https://github.com/Oleafly/oleafly-server/releases). Sunucunun tek bir Linux programı olarak hâli [Oleafly sürümleri sayfasındadır](https://github.com/Oleafly/Oleafly/releases).

## Nasıl çalıştıracağınızı seçin

| Seçenek | Ne zaman kullanılır |
| --- | --- |
| [Tek komutla kurulum](#install-with-one-command) | Kendi baktığınız bir Linux makinesi. Yükleyici Docker'ı, Caddy'yi ve HTTPS'yi kurar ve birkaç soru sorar. Emin değilseniz buradan başlayın. |
| [Docker Compose'u elle kurma](#docker-compose-by-hand) | Her dosyayı kendiniz yerleştirmeyi ve düzenlemeyi tercih ediyorsanız. |
| [Coolify](#coolify) | Zaten bir Coolify sunucunuzu çalıştırıyorsanız. |
| [Render](#render) ya da [Railway](#railway) | Makineye bakmak yerine bir barındırma hizmetine para ödemeyi tercih ediyorsanız. |
| [Docker'sız Linux](#linux-without-docker) | Docker kullanamadığınız bir üniversite sanal makinesi. |

Sunucu ayarlarını ortam değişkenlerinden okur. [Depolama, yedekler ve limitler](/docs/collaboration/server-operations/#settings) sayfası hepsini listeler.

## Tek komutla kurulum

Kendi baktığınız bir Linux makinesinde yükleyici her şeyi kurar ve yalnızca bilmesi gerekenleri sorar.

Çalıştırmadan önce şunları denetleyin:

- Makine, örneğin Ubuntu 24.04 ya da Debian 13 gibi, x86-64 ya da ARM üzerinde Linux çalıştırıyor ve üzerinde `sudo` kullanabiliyorsunuz.
- Makinede başka hiçbir şey 80 ve 443 portlarını kullanmıyor. Önündeki varsa güvenlik duvarında TCP 80 ve 443 ile UDP 443 portlarını açın.
- Alan adınızın DNS kaydı makineye işaret ediyor. Henüz etmiyorsa kurulum yine de biter ve Caddy, kayıt yerine oturana kadar sertifika almayı denemeye devam eder.
- Elinizde en az bir [oturum açma sağlayıcısının](/docs/collaboration/server-access/#sign-in-providers) bilgileri var; örneğin bir GitHub OAuth uygulamasının istemci kimliği ve parolası. GitHub için geri çağırma adresi, `https://` ve alan adınız, ardından `/auth/callback/github` şeklindedir.

:::note[Beta sürümü sırasında]
Sunucunun Oleafly 0.4.7-rc ile eşleşmesi için sürüm adayını, Oleafly Server 0.1.1-rc'yi kurun:

```sh
curl -fsSL https://github.com/Oleafly/oleafly-server/releases/download/server-v0.1.1-rc/install.sh | sudo sh
```

Aşağıdaki komut 0.1.0'ı kurar; bu daha eski bir sürümdür. İmajı başka bir yolla, örneğin Compose, Coolify, Render ya da Railway ile çalıştırıyorsanız `ghcr.io/oleafly/oleafly-server:0.1.1-rc` kullanın.
:::

Şimdi şunu çalıştırın:

```sh
curl -fsSL https://oleafly.com/server/install.sh | sudo sh
```

Yükleyici:

1. Makineyi ve 80 ile 443 portlarının boş olduğunu denetler.
2. Docker'ı denetler. Yoksa yükleyici, Docker'ın kendi betiğiyle kurmadan önce sorar.
3. En yeni sürümün dosyalarını [Oleafly Server sürümlerinden](https://github.com/Oleafly/oleafly-server/releases) indirir ve her birini sürümün `SHA256SUMS` dosyasıyla karşılaştırır. Bir dosya uymazsa hiçbir şeyi değiştirmeden durur.
4. Alan adınızı, sunucunun adını ve kişilerin nasıl oturum açacağını sorar. Ayrıca e-posta kurmayı ve dosyaları bir S3 kovasında tutmayı da önerir. İkisi de isteğe bağlıdır.
5. Bir özet gösterir ve herhangi bir şeyi değiştirmeden önce sorar. Sonra dosyalarını `/opt/oleafly-server` içine yazar; ayarlarınız, yalnızca kök kullanıcının okuyabildiği `.env` içindedir.
6. Sunucuyu önünde Caddy ile başlatır, alan adınız HTTPS üzerinden yanıt verene kadar bekler ve adresle birlikte kurulum kodunu yazdırır.

Sonra [ilk yönetici olun](#become-the-first-admin).

Yükleyiciyi istediğiniz zaman yeniden çalıştırabilirsiniz. `/opt/oleafly-server` içinde bir sunucu bulduğunda `.env` dosyasını olduğu gibi korur, diğer dosyaları geri koyar ve sunucuyu yeniden başlatır. Bu, bozuk kurulumların çoğunu onarır.

Verileriniz `oleafly-server_oleafly-data` Docker biriminde durur. `/opt/oleafly-server` dışında bir yere kurmak için `OLEAFLY_DIR` ayarlayın, örneğin `curl -fsSL https://oleafly.com/server/install.sh | sudo OLEAFLY_DIR=/srv/oleafly sh`, ve aşağıdaki komutlarda o klasörü kullanın.

### Önce yükleyiciyi okuyun

Kurumunuz bir betiğin kabuğa borulanmasına izin vermiyorsa `install.sh` ve `SHA256SUMS` dosyalarını [en son sürümden](https://github.com/Oleafly/oleafly-server/releases/latest) tek bir klasöre indirin. Betiği denetleyin, okuyun, sonra çalıştırın:

```sh
sha256sum --check --ignore-missing SHA256SUMS
sudo sh install.sh
```

### Soru sormadan kurulum

Bir betik ya da hazırlık aracı için `--yes` ekleyin ve yanıtları ortam değişkenleri olarak geçirin. `OLEAFLY_INSTALL_DOCKER=yes`, Docker eksikse yükleyicinin onu kurmasına izin verir.

```sh
curl -fsSL https://oleafly.com/server/install.sh | sudo \
  OLEAFLY_DOMAIN=collab.example.org \
  OLEAFLY_SERVER_NAME='Smith Lab' \
  OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId \
  OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret \
  OLEAFLY_INSTALL_DOCKER=yes \
  sh -s -- --yes
```

Yükleyici, ortamda bulduğu her ayarı `--yes` olsun ya da olmasın sormadan kullanır. `sudo sh /opt/oleafly-server/install.sh --help` komutu hepsini listeler; OpenID Connect, e-posta ve S3 dahil. Komut satırına yazılan değerler kabuk geçmişinize düşebilir; bu yüzden bir hazırlık aracı gizli bilgileri kendi gizli bilgi deposundan geçirmelidir.

### Durum, güncellemeler ve kaldırma

- **Durum**: `sudo sh /opt/oleafly-server/install.sh status`, sunucunun çalışıp çalışmadığını ve alan adınızın geçerli bir sertifikayla HTTPS üzerinden yanıt verip vermediğini gösterir.
- **Güncelleme**: önce [Güncelleme](/docs/collaboration/server-operations/#updating) sayfasında anlatıldığı gibi yedek alın. Sonra aşağıdaki komutu çalıştırın. En yeni sürümün dosyalarını ve imajını indirir, `.env` dosyasını korur, sunucuyu yeniden başlatır ve yanıt verene kadar bekler. Bağlı kişiler kendi kendilerine yeniden bağlanır. Yükleyici bir sunucuyu asla daha eski bir sürüme taşımaz.

  ```sh
  curl -fsSL https://oleafly.com/server/install.sh | sudo sh -s -- update
  ```

- **Kaldırma**: `sudo sh /opt/oleafly-server/install.sh uninstall` kapsayıcıları durdurur ve kaldırır. Verileriniz ve `.env` dosyanız, sorduğunda `delete` yazmadıkça kalır. Onları silmek, sunucudaki her paylaşılan projeyi, her hesabı ve güvenlik günlüğünü kaldırır. Kişiler, projelerin kendi kopyalarını bilgisayarlarında tutmaya devam eder.

Yükleyici çözemediğiniz bir sorunla durursa, yazdırdıklarıyla birlikte [bildirin](https://github.com/Oleafly/oleafly-server/issues/new/choose).

## Docker Compose'u elle kurma

Bu kurulum iki kapsayıcı çalıştırır. `oleafly-server` sunucudur ve ona yalnızca diğer kapsayıcılar ulaşabilir. `caddy`, Let's Encrypt'ten sertifika alır, 80 ve 443 portlarında HTTPS sunar ve istekleri, canlı bağlantılar dahil, sunucuya geçirir.

1. Docker Engine ve Compose eklentisini [Docker'ın yönergelerini](https://docs.docker.com/engine/install/) izleyerek kurun.
2. Alan adınızın DNS kaydını makineye yönlendirin. Önündeki varsa güvenlik duvarında TCP 80 ve 443 ile UDP 443 portlarını açın. Caddy'nin sertifikayı alması için 80. port gerekir.
3. Sunucu için bir klasör oluşturun, en yeni sürümün dosyalarını içine indirin, denetleyin ve ayar dosyanızı oluşturun:

   ```sh
   sudo mkdir -p /opt/oleafly-server && cd /opt/oleafly-server
   base=https://github.com/Oleafly/oleafly-server/releases/latest/download
   for f in docker-compose.yml Caddyfile env.example litestream.yml SHA256SUMS; do sudo curl -fsSLO "$base/$f"; done
   sha256sum --check --ignore-missing SHA256SUMS
   sudo install -m 600 env.example .env
   ```

4. `.env` dosyasını `sudoedit .env` ile düzenleyin. `OLEAFLY_DOMAIN` değerini `https://` olmadan alan adınıza ayarlayın, `OLEAFLY_SERVER_NAME` değerini girin ve en az bir [oturum açma sağlayıcısını](/docs/collaboration/server-access/#sign-in-providers) doldurun. Kullanmadığınız sağlayıcı satırlarını boş bırakın. `$` ya da `#` içeren bir değeri tek tırnak içine yazın.
5. Başlatın. İlk başlatma, sunucu imajını `ghcr.io/oleafly/oleafly-server` adıyla, sürüm dosyalarındaki sürümüne göre indirir.

   ```sh
   sudo docker compose up -d
   ```

6. Yanıt verdiğini denetleyin. Bu komut `200` yazdırır:

   ```sh
   curl -sS -o /dev/null -w '%{http_code}\n' https://collab.example.org/healthz
   ```

7. [İlk yönetici olun](#become-the-first-admin). Kurulum kodu günlükte:

   ```sh
   sudo docker compose logs oleafly-server | grep 'Setup code'
   ```

Verileriniz `oleafly-server_oleafly-data` Docker biriminde durur. Caddy sertifikalarını `oleafly-server_caddy-data` içinde tutar.

Docker, `ufw` gibi bir ana makine güvenlik duvarı açıkken bile 80 ve 443 portlarını kendisi açar. Caddy'nin ihtiyacı olan budur. `oleafly-server` servisine bir `ports:` girdisi eklemeyin. Sunucuya makinenin kendisinden ulaşmak için onu `127.0.0.1:8080:8080` olarak yayımlayın; böylece ağdan uzak kalır.

`Caddyfile` dosyasını değiştirirseniz `sudo docker compose up -d --force-recreate caddy` çalıştırın. Sonradan güncellemek için yeni sürümün dosyalarını aynı yolla indirin ve `sudo docker compose up -d` komutunu yeniden çalıştırın.

### Gizli bilgileri .env dışında tutma

Yedi ayar gizli bilgi tutabilir: `OLEAFLY_SETUP_CODE`, `OLEAFLY_GITHUB_CLIENT_SECRET`, `OLEAFLY_OIDC_<NAME>_CLIENT_SECRET`, `OLEAFLY_SMTP_URL`, `OLEAFLY_BLOB_STORE`, `OLEAFLY_S3_ACCESS_KEY_ID` ve `OLEAFLY_S3_SECRET_ACCESS_KEY`. Her birinin, değeri tutan dosyayı adlandıran bir `_FILE` sürümü de vardır. İkisinden birini ayarlayın, ikisini birden değil.

Örneğin GitHub istemci parolasını bir Docker secret olarak geçirmek için onu `docker-compose.yml` yanındaki `secrets/github_client_secret` dosyasına kaydedin, sunucunun kullanıcısının (kimliği 10001) okuyabilmesini sağlayın ve `.env` içinden `OLEAFLY_GITHUB_CLIENT_SECRET` satırını silin:

```sh
sudo chown 10001:10001 secrets/github_client_secret
sudo chmod 400 secrets/github_client_secret
```

Sonra `docker-compose.yml` yanında `docker-compose.override.yml` oluşturun. Compose onu kendiliğinden okur ve yükleyici, diğer dosyaları güncellerken ona dokunmaz.

```yaml
services:
  oleafly-server:
    environment:
      OLEAFLY_GITHUB_CLIENT_SECRET_FILE: /run/secrets/github_client_secret
    secrets:
      - github_client_secret

secrets:
  github_client_secret:
    file: ./secrets/github_client_secret
```

`sudo docker compose up -d` komutunu yeniden çalıştırın.

## Coolify

Coolify, sunucunun önüne kendi vekil sunucusunu koyar ve sertifikayı alır; bu yüzden bu kurulumda Caddy yoktur. Coolify, sunucuyu Oleafly deposundan derleyebilir ya da derlemeyi atlayan [yayımlanmış imajı](#deploy-the-published-image) çalıştırabilir.

Başlamadan önce alan adınızın DNS kaydını, örneğin `collab.example.org`, Coolify sunucusuna yönlendirin. Sonra [GitHub](/docs/collaboration/server-access/#github) bölümünde anlatıldığı gibi GitHub OAuth uygulamasını, geri çağırma adresi `https://collab.example.org/auth/callback/github` olacak şekilde oluşturun. İstemci kimliğini ve parolasını elinizin altında tutun.

### Depodan derleme

1. Coolify projenizde **+ New**'i, sonra **Public Repository**'yi seçin ve `https://github.com/Oleafly/Oleafly` adresini girin. Dal olarak `main` kalsın.
2. **Build Pack** seçeneğini **Docker Compose**, **Base Directory** seçeneğini `/` ve **Docker Compose Location** seçeneğini `/deploy/server/docker-compose.coolify.yml` olarak ayarlayın, sonra **Continue**'yi seçin.
3. **Advanced › Build** altında **Build arguments** seçeneğini **Managed manually in Dockerfile** yapın. Sunucunun imajı derleme argümanı istemez. Otomatik bırakılırsa Coolify, gizli bilgiler dahil her değişkeni imajın derleme geçmişine yazar.
4. **General** altında `oleafly-server` servisinin etki alanını `https://collab.example.org:8080` olarak ayarlayın ve kaydedin. `:8080`, Coolify'nin vekil sunucusuna sunucunun hangi portu dinlediğini söyler. Kişiler yine her zamanki HTTPS portundan bağlanır ve Coolify, `OLEAFLY_PUBLIC_URL` değerini sizin için `https://collab.example.org` yapar.
5. **Environment Variables** altında Coolify'nin zorunlu işaretlediği `OLEAFLY_SERVER_NAME` değerini, ardından `OLEAFLY_GITHUB_CLIENT_ID` ve `OLEAFLY_GITHUB_CLIENT_SECRET` değerlerini doldurun. Kullanmadığınız değişkenleri boş bırakın.
6. **Deploy**'ı seçin. İlk derleme sunucuyu derler ve birkaç dakika sürer. Bittiğinde Coolify, kaynağı çalışıyor ve sağlıklı olarak gösterir.
7. Bir tarayıcıda `https://collab.example.org/healthz` adresini açın. `{"status":"ok"}` gösterir.
8. **Logs**'u açın, `oleafly-server` kapsayıcısını seçin ve `Setup code:` ile başlayan en yeni satırdaki kodu kopyalayın.
9. O kodla [ilk yönetici olun](#become-the-first-admin).

Sunucu başlamazsa günlüğü, kullanamadığı ayarın adını yazar. `OLEAFLY_PUBLIC_URL` ayarlı değil diyorsa 4. adım eksiktir. `http://` ile başlayan bir etki alanı reddedilir, çünkü sunucunun HTTPS'ye ihtiyacı vardır.

DNS kaydınız Cloudflare'nin vekil sunucusundan geçtiği ya da bir tünel Coolify'nin vekil sunucusuna çıktığı için Cloudflare Coolify'nin önündeyse `OLEAFLY_PROXY_HOPS` değerini `2` yapın. Olmazsa güvenlik günlüğü herkese vekil sunucunun adresini gösterir ve hepsi tek bir oturum açma sınırını paylaşır.

Coolify dosyası GitHub ile `UNIVERSITY` adlı bir OpenID Connect sağlayıcısına yer bırakır. `OLEAFLY_OIDC_UNIVERSITY_LABEL` değerini kişilerin görmesini istediğiniz metne ayarlayın, örneğin `GitLab`. Onun geri çağırma adresi `/auth/callback/university` ile biter. Daha fazla sağlayıcı için, dosyanın kendi kopyanızla bir fork'tan dağıtın.

Veriler, adı `oleafly-data` ile biten bir Docker biriminde durur. `docker volume ls --filter name=oleafly-data` komutuyla bulun. İmajda kabuk olmadığından Coolify'nin **Terminal**'i sunucunun kapsayıcısında kabuk açamaz. Günlükler ve sağlık denetimi her zamanki gibi çalışır.

### Yayımlanan imajı dağıtma

Yayımlanan imajı çalıştırmak derlemeyi atlar; bu küçük bir Coolify sunucusuna uyar. Yukarıdaki adımları iki değişiklikle izleyin. 2. adımda **Docker Compose Location** değerini `/deploy/server/docker-compose.coolify-image.yml` yapın. Hiçbir şey derlenmediği için 3. adımı atlayın. Dosya tek bir sürüm serisini izler; bu yüzden her **Redeploy**, o serideki en yeni sürümü çeker.

## Render

[Render'a dağıt](https://render.com/deploy?repo=https://github.com/Oleafly/Oleafly) bağlantısı, Oleafly deposundaki Blueprint'i okur. Yayımlanmış imajdan tek bir web servisi oluşturur; veri klasörü için 1 GB disk bulunur. Render diskleri yalnızca ücretli örnek türlerine takar; bu yüzden servis, Render'ın Oregon bölgesindeki en küçük ücretli örnekte başlar. Başka bir bölge için `render.yaml` içinde `region` ayarlanmış bir fork'tan dağıtın.

1. Bağlantıyı açın ve Render'da oturum açın.
2. Render, `OLEAFLY_SERVER_NAME` ile GitHub istemci kimliğini ve parolasını ister. Adı doldurun ve GitHub alanlarını şimdilik boş bırakın. Onların geri çağırma adresi, henüz elinizde olmayan servisin adresine bağlıdır.
3. **Deploy Blueprint**'i seçin. Servis yayına girdiğinde sayfası adresini gösterir, örneğin `https://oleafly-server.onrender.com`. Blueprint, `OLEAFLY_PUBLIC_URL` değerini o adrese ayarlar.
4. GitHub OAuth uygulamasını [GitHub](/docs/collaboration/server-access/#github) bölümünde anlatıldığı gibi oluşturun; geri çağırma adresi, o adresin sonuna `/auth/callback/github` eklenmiş hali olsun. İstemci kimliğini ve parolasını servisin **Environment** bölümüne ekleyin. Render, sunucuyu onlarla yeniden başlatır.
5. Servisin **Logs** bölümündeki en yeni `Setup code:` satırını bulun ve [ilk yönetici olun](#become-the-first-admin).

Servise kendi alan adınızı verirseniz **Environment** altında `OLEAFLY_PUBLIC_URL` değerini ona ayarlayın ve GitHub'daki geri çağırma adresini buna uyacak şekilde değiştirin.

Disk yüzünden Render, yenisini başlatmadan önce çalışan sunucuyu durdurur; bu yüzden her dağıtım sunucuyu birkaç saniyeliğine devre dışı bırakır. Oleafly kendi kendine yeniden bağlanır.

## Railway

Railway, yayımlanan imajı, veri klasörü için bir birimle çalıştırır.

1. Bir Railway projesinde **+ New**'i, ardından **Docker Image**'ı seçin ve `ghcr.io/oleafly/oleafly-server:latest` girin. Ne zaman güncelleyeceğinizi kendiniz seçmek için bunun yerine [sürümler sayfasındaki](https://github.com/Oleafly/Oleafly/releases) bir sürümün kendi etiketini kullanın. Railway ilk dağıtımı hemen başlatabilir. Dağıtım `OLEAFLY_PUBLIC_URL is not set` ile durur; bu noktada beklenen bir durumdur.
2. Servisi açın. **Settings › Networking** altında **Generate Domain**'i seçin ve port olarak `8080` girin. Railway adresi gösterir, örneğin `oleafly-server-production.up.railway.app`.
3. **Settings › Deploy** altında **Healthcheck Path** değerini `/readyz` yapın.
4. Proje tuvaline sağ tıklayın, bir birim ekleyin, onu sunucunun servisine bağlayın ve bağlama yolunu `/data` yapın.
5. **Variables** altında **Raw Editor**'ü açın ve şu satırları kendi sunucu adınızla yapıştırın. GitHub değerleri için [GitHub](/docs/collaboration/server-access/#github) bölümünü izleyin. Geri çağırma adresi, 2. adımdaki adresin önüne `https://` konulup sonuna `/auth/callback/github` eklenmiş hâlidir.

   ```ini
   OLEAFLY_PUBLIC_URL=https://${{RAILWAY_PUBLIC_DOMAIN}}
   OLEAFLY_BIND=0.0.0.0:8080
   OLEAFLY_DATA_DIR=/data
   OLEAFLY_BEHIND_PROXY=true
   OLEAFLY_SERVER_NAME=Smith Lab
   OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId
   OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret
   PORT=8080
   RAILWAY_RUN_UID=0
   ```

   Railway birimleri kök kullanıcı olarak bağlar. `RAILWAY_RUN_UID=0`, sunucunun birime yazabilmesi için onu kök kullanıcı olarak çalıştırır.

6. Değişiklikleri dağıtın. Servisin **Deploy Logs** bölümündeki en yeni `Setup code:` satırını bulun ve [ilk yönetici olun](#become-the-first-admin).

## Docker'sız Linux

Docker olmayan bir makinede sunucu, systemd altında tek bir program olarak, HTTPS için önünde Caddy ile çalışır.

### Sunucuyu indirme

[Sürümler sayfasındaki](https://github.com/Oleafly/Oleafly/releases) her sunucu sürümünde x86-64 ve ARM için derlenmiş hazır bir program ve onu denetlemek için kullanılacak bir `SHA256SUMS` dosyası vardır. Programın çalışması için başka hiçbir şeyin kurulması gerekmez.

Makinenize uygun arşivi, `x86_64-unknown-linux-musl.tar.gz` ya da `aarch64-unknown-linux-musl.tar.gz` ile biten olanı, ve `SHA256SUMS` dosyasını tek bir klasöre indirin. Sonra denetleyip kurun. ARM bir makinede `x86_64` yerine `aarch64` kullanın:

```sh
sha256sum --check --ignore-missing SHA256SUMS
tar -xzf oleafly-server-*-x86_64-unknown-linux-musl.tar.gz
sudo install -m 0755 oleafly-server-*-x86_64-unknown-linux-musl/oleafly-server /usr/local/bin/oleafly-server
oleafly-server --version
```

GitHub CLI kuruluysa `gh attestation verify oleafly-server-*-x86_64-unknown-linux-musl.tar.gz --repo Oleafly/Oleafly` komutu, GitHub'ın arşivi Oleafly deposundan derlediğini de denetler. Arşivde systemd birimi olan `oleafly-server.service` de bulunur.

Bunun yerine programı kendiniz derlemek için bu komutu, Docker olan herhangi bir bilgisayarda Oleafly deposunun bir klonundan çalıştırın. ARM bir sunucu için `--platform linux/arm64` kullanın.

```sh
docker buildx build --platform linux/amd64 --target binary --output type=local,dest=dist -f crates/oleafly-server/Dockerfile .
```

Bu komut `dist/oleafly-server` dosyasını yazar. Onu sunucudaki `/usr/local/bin/oleafly-server` yoluna kopyalayın ve çalıştırılabilir yapın.

### systemd ile çalıştırma

1. Ayarlar dosyasını oluşturun. Yalnızca kök kullanıcı okuyabilir:

   ```sh
   sudo install -d -m 0755 /etc/oleafly-server
   sudo install -m 0600 /dev/null /etc/oleafly-server/oleafly-server.env
   sudoedit /etc/oleafly-server/oleafly-server.env
   ```

   Her satıra bir ayar yazın. `OLEAFLY_BIND=127.0.0.1:8080`, sunucuyu ağdan uzak tutar; böylece ona yalnızca Caddy ulaşabilir. `OLEAFLY_DATA_DIR` ayarlamayın, çünkü birim onu ayarlar.

   ```ini
   OLEAFLY_PUBLIC_URL=https://collab.example.org
   OLEAFLY_BIND=127.0.0.1:8080
   OLEAFLY_BEHIND_PROXY=true
   OLEAFLY_SERVER_NAME=Smith Lab
   OLEAFLY_GITHUB_CLIENT_ID=Ov23liExampleClientId
   OLEAFLY_GITHUB_CLIENT_SECRET=example-client-secret
   ```

2. Birimi, arşivden açılan dosyalardan ya da deponun bir klonundaki `deploy/server` klasöründen kurun ve başlatın. Sonra kurulum kodunu bulun:

   ```sh
   sudo install -m 0644 oleafly-server.service /etc/systemd/system/oleafly-server.service
   sudo systemctl daemon-reload
   sudo systemctl enable --now oleafly-server
   sudo journalctl -u oleafly-server | grep 'Setup code'
   ```

Birim, sunucuyu systemd'nin onun için oluşturduğu bir kullanıcı olarak çalıştırır; kullanıcı sistemin geri kalanını salt okunur görür. Yazabildiği tek yer, verilerini tuttuğu `/var/lib/oleafly-server` klasörüdür. Diskte o klasör `/var/lib/private/oleafly-server` şeklindedir.

İstemci parolasını ayarlar dosyasının dışında tutmak için bir systemd credential kullanın. Parolayı 600 kipinde `/etc/oleafly-server/github-client-secret` dosyasına kaydedin, ayarlar dosyasından `OLEAFLY_GITHUB_CLIENT_SECRET` satırını silin, `sudo systemctl edit oleafly-server` komutunu çalıştırın ve şunları ekleyin:

```ini
[Service]
LoadCredential=github-client-secret:/etc/oleafly-server/github-client-secret
Environment=OLEAFLY_GITHUB_CLIENT_SECRET_FILE=%d/github-client-secret
```

Sonra `sudo systemctl restart oleafly-server` komutunu çalıştırın.

### Önüne HTTPS koyma

Caddy'yi [dağıtımınıza uygun yönergelerle](https://caddyserver.com/docs/install) kurun. `/etc/caddy/Caddyfile` dosyasını şu satırlarla değiştirin ve `sudo systemctl reload caddy` komutunu çalıştırın. Caddy sertifikayı alır ve canlı bağlantıları geçirir.

```
collab.example.org {
	reverse_proxy 127.0.0.1:8080
}
```

nginx ya da Apache için, ya da üniversitenizin zaten çalıştırdığı bir web sunucusu için [Ters vekil sunucu arkasında](/docs/collaboration/server-operations/#behind-a-reverse-proxy) bölümünü okuyun.

## Genel adres olmadan

Makinenin genel adresi yoksa, örneğin makine üniversite güvenlik duvarının arkasındaki laboratuvarınızdaki bir bilgisayarsa, Cloudflare Tunnel onu erişilebilir kılabilir. Alan adınızın bulunduğu bir Cloudflare hesabına ihtiyacınız vardır. Cloudflare, ana makine adı için HTTPS'yi halleder; bu yüzden istekler, makinenize ulaşmadan önce Cloudflare'nin ağında şifresi çözülür. Sunucunuza giden trafiği okuyabilecek taraflar arasına Cloudflare'yi de sayın.

1. [Docker Compose'u elle kurma](#docker-compose-by-hand) adımlarını `.env` dosyasını düzenleyene kadar izleyin. `OLEAFLY_DOMAIN` değerini kullanacağınız ana makine adına ayarlayın, örneğin `collab.example.org`. Tek komutlu yükleyici buraya uymaz, çünkü Caddy'yi başlatır.
2. Yalnızca sunucuyu başlatın. Burada Caddy gerekmez:

   ```sh
   sudo docker compose up -d oleafly-server
   ```

3. Cloudflare panosunda **Networking › Tunnels** bölümüne gidin, **Create Tunnel**'i seçin, bir ad verin ve **Create Tunnel**'i yeniden seçin. Gösterdiği kurulum komutundaki jetonu kopyalayın.
4. Tüneli sunucunun yanında başlatın. `read` komutu jetonu yapıştırmanızı bekler ve onu göstermez:

   ```sh
   read -rs TUNNEL_TOKEN && export TUNNEL_TOKEN
   sudo --preserve-env=TUNNEL_TOKEN docker run -d --name oleafly-tunnel --restart unless-stopped --network oleafly-server_default -e TUNNEL_TOKEN cloudflare/cloudflared:2026.10.0 tunnel --no-autoupdate run
   ```

5. Panoya dönüp tüneli açın. **Routes** altında **Add Route**'u, sonra **Published application**'ı seçin. **Hostname** altında alt alan adını girin ve alan adınızı seçin. **Service URL** değerini `http://oleafly-server:8080` yapın ve **Add Route**'u seçin.
6. `https://collab.example.org/healthz` adresinin yanıt verdiğini denetleyin, sonra [ilk yönetici olun](#become-the-first-admin).

Docker olmayan bir makinede `cloudflared` programını [Cloudflare'nin paket deposundan](https://pkg.cloudflare.com/) kurun, `sudo cloudflared service install` komutunu ve ardından jetonu çalıştırın ve **Service URL** değerini `http://127.0.0.1:8080` yapın.

Cloudflare canlı bağlantıları geçirir ve ziyaretçinin adresini `X-Forwarded-For` içinde en sona koyar; bu yüzden `OLEAFLY_BEHIND_PROXY=true` kalsın. Tünel, doğrudan sunucuya değil de Coolify'ninki gibi başka bir vekil sunucuya çıkıyorsa `OLEAFLY_PROXY_HOPS=2` ayarını da yapın. Cloudflare, Free ve Pro planlarında 100 MB'tan büyük istekleri reddeder; bu yüzden `OLEAFLY_MAX_PROJECT_MB` değerini 100 ya da daha küçük yapın, yoksa büyük projeler yüklenemez. Cloudflare Access'i sunucunun önüne koymayın, çünkü Oleafly onun oturum sayfasını geçemez.

Sunucuyu sonradan güncellediğinizde yeni sürümün dosyalarını indirin ve servisi adıyla belirtin; böylece Caddy devre dışı kalır: `sudo docker compose up -d oleafly-server`.

## İlk yönetici olma

Yeni bir sunucuda yönetici yoktur. Biri kurulumu bitirene kadar sunucu, her başladığında yeni bir tek kullanımlık kurulum kodu üretir ve günlüğüne yazar.

1. Günlükte `Setup code:` ile başlayan en yeni satırı bulun:
   - Tek komutlu kurulum: yükleyici, işini bitirdiğinde onu yazdırır. Yeniden görmek için `cd /opt/oleafly-server && sudo docker compose logs oleafly-server | grep 'Setup code'` komutunu çalıştırın
   - Docker Compose'u elle kurma: sunucunun klasöründe `sudo docker compose logs oleafly-server | grep 'Setup code'`
   - Coolify: `oleafly-server` servisinin günlükleri
   - systemd: `sudo journalctl -u oleafly-server | grep 'Setup code'`
2. Oleafly'de **Ayarlar → İş Birliği**'ni açın, **Sunucu ekle**'yi seçin ve sunucunuzun adresini girin. Oleafly, sunucunun kuruluma ihtiyacı olduğunu görür ve **Kurulum kodu**'nu ister.
3. Kodu girin ve yapılandırdığınız herhangi bir sağlayıcıyla oturum açın. Sunucunun yöneticisi olursunuz ve kod çalışmayı bırakır.

Kodu siz kullanmadan önce ele geçiren herkes kendini yönetici yapabilir; bu yüzden onu yalnızca Oleafly'ye yapıştırın.

Kodu `OLEAFLY_SETUP_CODE` ile kendiniz de seçebilirsiniz: en az 12 harf ya da rakam; isterseniz tire ya da boşlukla. Sunucu o zaman onu hiç yazdırmaz. Günlük yalnızca `Setup code: set by OLEAFLY_SETUP_CODE` der, siz de ayarladığınız değeri girersiniz. Kurulum bitince onu ayarlarınızdan kaldırın.

Sıra kişileri içeri almaya geldi. [Oturum açma ve erişim](/docs/collaboration/server-access/#access-rules) sayfası nasıl yapılacağını anlatır.

## Sunucuyu denetleme

- Tek komutlu kurulumda `sudo sh /opt/oleafly-server/install.sh status`, kapsayıcıları ve HTTPS'yi tek seferde denetler.
- `https://collab.example.org/healthz`, sunucu süreci çalışırken `200` yanıtı verir.
- `/readyz`, yalnızca sunucu veritabanına ve veri klasörüne yazabilirken `200` yanıtı verir. Yazamadığında, örneğin disk dolduğunda, `503` yanıtı verir ve neyin başarısız olduğunu adlandırır: `database` ya da `storage`.
- Docker imajı `/readyz` adresini kendiliğinden denetler; bu yüzden `docker ps` ve Coolify, hiçbir şey kaydedemeyen çalışan bir sunucu yerine sağlıksız bir sunucu gösterir.
- Oleafly'de **Ayarlar → İş Birliği** altındaki **Bağlantıyı test et**, adresi, HTTPS'yi, sürümü, canlı bağlantıları, oturum açma seçeneklerini ve sunucunun saatini denetler. [Yönetici konsolundaki](/docs/collaboration/server-access/#admin-console) **Bağlantı denetimleri** aynı denetimleri çalıştırır.
