# सहयोग सर्वर चलाएँ

Oleafly Server क्या संग्रहीत करता है, उसे किन चीज़ों की आवश्यकता है, उसे एक कमांड से कैसे स्थापित करें, या Docker Compose, Coolify, Render, Railway या किसी साधारण Linux सेवा के साथ कैसे चलाएँ, और फिर उसके पहले एडमिन कैसे बनें।

Oleafly Server, लाइव सहयोग के पीछे का सहयोग सर्वर है। आपकी प्रयोगशाला, विभाग या संस्था उसे अपनी ही मशीनों पर या अपने ही क्लाउड खाते में चलाती है। लोग उसे Oleafly में जोड़ते हैं और अपने पास पहले से मौजूद किसी खाते, जैसे GitHub या किसी विश्वविद्यालय लॉगिन, से साइन इन करते हैं। जब कोई सर्वर पर कोई प्रोजेक्ट साझा करता है, तो जिन लोगों को वह जोड़ता है उन्हें उसकी एक पूरी प्रति मिलती है, जो संपादन के दौरान सिंक बनी रहती है। [ब्राउज़र से पहुँच](/docs/collaboration/server-access/#browser-access) चालू होने पर वे उसे किसी वेब ब्राउज़र में भी खोल सकते हैं।

यह गाइड उस व्यक्ति के लिए है जो किसी प्रयोगशाला, पाठ्यक्रम या सह-लेखकों के समूह के लिए सर्वर चलाता है। आपको टर्मिनल से काम करने में सहज होना चाहिए। कुछ सेटअप में आपको एक कॉन्फ़िगरेशन फ़ाइल भी संपादित करनी पड़ सकती है। आपको कोड लिखने की ज़रूरत नहीं है।

अपनी सुरक्षा समीक्षा के लिए [सर्वर सुरक्षा](/security/) पढ़ें। इसमें सेल्फ-होस्टिंग, साइन-इन, डिवाइस कुंजियाँ, हस्ताक्षरित बदलाव, सुरक्षा और पहुँच लॉग, और सॉफ़्टवेयर बिल ऑफ़ मैटीरियल्स के साथ कंटेनर इमेज शामिल है।

## सर्वर क्या रखता है

सर्वर सब कुछ एक ही डेटा फ़ोल्डर में रखता है, जिसे `OLEAFLY_DATA_DIR` से सेट किया जाता है:

- **खाते**: प्रत्येक सदस्य का प्रदर्शन नाम, अवतार पता, सत्यापित ईमेल पते, और साइन-इन प्रोवाइडर पर उनकी यूज़र ID और लॉगिन। सर्वर कभी पासवर्ड नहीं देखता या संग्रहीत नहीं करता।
- **डिवाइस**: हर कंप्यूटर जिसने साइन इन किया, उसका नाम, ऑपरेटिंग सिस्टम, पब्लिक कुंजी और वह आख़िरी बार कब देखा गया। साइन-इन टोकन केवल हैश के रूप में संग्रहीत होते हैं।
- **सुरक्षा लॉग**: साइन-इन और अस्वीकृत साइन-इन, जोड़े गए और साइन-आउट किए गए डिवाइस, सदस्यों, भूमिकाओं और सेटिंग्स में बदलाव, साझा, संग्रहीत और पुनर्स्थापित प्रोजेक्ट, यह कि कौन कोई प्रोजेक्ट खोल सकता है इसमें बदलाव, और अतिथि आमंत्रण। प्रत्येक प्रविष्टि में समय और IP पता होता है।
- **सर्वर सेटिंग्स**, जो एडमिन Oleafly में बदलते हैं।
- **प्रोजेक्ट पहुँच लॉग**, उन प्रोजेक्ट के लिए जिनका मालिक इनमें से किसी एक को चालू करता है: किसने प्रोजेक्ट खोला, उससे जुड़ा या उसकी प्रति डाउनलोड की, डिवाइस के नाम और समय के साथ। केवल प्रोजेक्ट का मालिक ही उसे पढ़ सकता है।
- **अतिथि आमंत्रण**: आमंत्रित ईमेल पता, प्रोजेक्ट, भूमिका और किसने भेजा।
- **साझा प्रोजेक्ट**: हर फ़ाइल और बदलावों का पूरा इतिहास, साथ में उनसे जुड़ी टिप्पणियाँ, सुझाव, चैट और वर्शन के नाम।
- **कंपाइल की गई PDF**: हर साझा प्रोजेक्ट के लिए सबसे नई PDF और उसकी SyncTeX फ़ाइल, जो किसी मालिक या संपादक के ऐप ने सफल कंपाइल के बाद भेजी, साथ में यह कि उसे किसने और कब कंपाइल किया।

सुरक्षा लॉग और पहुँच लॉग की प्रविष्टियाँ, और उत्तर दिए गए या समाप्त हो चुके अतिथि आमंत्रण, `OLEAFLY_SECURITY_LOG_DAYS` दिनों बाद हटा दिए जाते हैं, जो डिफ़ॉल्ट रूप से 365 है। जो फ़ाइलें कोई प्रोजेक्ट अब उपयोग नहीं करता, जैसे बदली हुई आकृति की पुरानी प्रति, उन्हें प्रोजेक्ट के आख़िरी उपयोग के 30 दिनों बाद हटा दिया जाता है। हर कंपाइल की गई PDF पिछली PDF की जगह ले लेती है। जब कोई मालिक किसी प्रोजेक्ट को साझा करना बंद कर देता है, तो सर्वर उसे `OLEAFLY_ARCHIVE_DAYS` दिनों तक केवल-पढ़ने-योग्य रखता है, जो डिफ़ॉल्ट रूप से 30 है, और फिर उसे हटा देता है। उस अवधि में केवल मालिक और प्रोजेक्ट के कोई भी एडमिन उसे डाउनलोड कर सकते हैं।

### कौन प्रोजेक्ट पढ़ सकता है

प्रोजेक्ट सर्वर पर एन्क्रिप्टेड नहीं होते। जो कोई भी डेटा फ़ोल्डर, मशीन की डिस्क या आपके बैकअप पढ़ सकता है, वह वहाँ संग्रहीत हर प्रोजेक्ट पढ़ सकता है। इसमें मशीन चलाने वाला व्यक्ति और उसे होस्ट करने वाली कंपनी भी शामिल है।

Oleafly के भीतर नियम सख़्त हैं। कोई भी सर्वर भूमिका, एडमिन सहित, कोई प्रोजेक्ट नहीं खोल सकती जब तक प्रोजेक्ट के मालिक ने उसे न जोड़ा हो। अगर किसी प्रोजेक्ट को सर्वर चलाने वाले लोगों से दूर रखना ज़रूरी हो, तो उसके लिए एक अलग सर्वर चलाएँ।

हर सदस्य का कंप्यूटर भी उनके साथ साझा किए गए हर प्रोजेक्ट की एक पूरी प्रति रखता है। सदस्यों से कहें कि वे डिस्क एन्क्रिप्शन चालू रखें, जैसे macOS पर FileVault, Windows पर BitLocker या Linux पर LUKS।

## आपको किन चीज़ों की ज़रूरत है

- **एक मशीन जो चालू रहे**। कोई भी Linux मशीन काम करती है, या Render या Railway जैसी होस्टिंग सेवा का खाता। शुरुआत के लिए एक छोटी वर्चुअल मशीन काफ़ी है। प्रोजेक्ट बढ़ने के साथ उसकी मेमोरी और डिस्क पर नज़र रखें। सर्वर x86-64 और ARM पर चलता है।
- **एक डोमेन नाम** सर्वर के लिए, जैसे `collab.example.org`, जिसका DNS रिकॉर्ड मशीन की ओर इशारा करता हो। अगर आपके पास पता नहीं है तो Render और Railway आपको एक पता दे देते हैं। अगर मशीन का कोई सार्वजनिक पता नहीं है, तो [बिना सार्वजनिक पता के](#without-a-public-address) पढ़ें।
- **लोगों के साइन इन करने का एक तरीका**: कम से कम एक साइन-इन प्रोवाइडर, जैसे कोई GitHub OAuth ऐप या आपकी संस्था का लॉगिन। इसके बिना सर्वर शुरू नहीं होता। एक ईमेल खाता, जिससे सर्वर भेज सके, वैकल्पिक है। उसके साथ, एक एडमिन लोगों को ईमेल किए गए लिंक से भी साइन इन करने दे सकता है। [साइन-इन और पहुँच](/docs/collaboration/server-access/) पढ़ें।

हर रिलीज़ एक कंटेनर इमेज, `ghcr.io/oleafly/oleafly-server`, के रूप में प्रकाशित होती है। इंस्टॉलर और उसकी Compose फ़ाइलें [Oleafly Server रिलीज़ पेज](https://github.com/Oleafly/oleafly-server/releases) पर हैं। एक अकेली Linux प्रोग्राम के रूप में सर्वर [Oleafly रिलीज़ पेज](https://github.com/Oleafly/Oleafly/releases) पर है।

## चलाने का तरीका चुनें

| विकल्प | इसे कब उपयोग करें |
| --- | --- |
| [एक कमांड](#install-with-one-command) | एक Linux मशीन जिसकी देखभाल आप करते हैं। इंस्टॉलर Docker, Caddy और HTTPS सेट करता है, और कुछ सवाल पूछता है। अगर आप निश्चित नहीं हैं तो यहीं से शुरू करें। |
| [Docker Compose स्वयं](#docker-compose-by-hand) | आप हर फ़ाइल ख़ुद रखना और संपादित करना पसंद करते हैं। |
| [Coolify](#coolify) | आप पहले से एक Coolify सर्वर चलाते हैं। |
| [Render](#render) या [Railway](#railway) | मशीन की देखभाल करने की बजाय आप किसी होस्टिंग सेवा को भुगतान करना पसंद करते हैं। |
| [Docker के बिना Linux](#linux-without-docker) | एक विश्वविद्यालय वर्चुअल मशीन जहाँ आप Docker उपयोग नहीं कर सकते। |

सर्वर अपनी सेटिंग्स environment variables से पढ़ता है। [स्टोरेज, बैकअप और सीमाएँ](/docs/collaboration/server-operations/#settings) उन सबकी सूची देता है।

## एक कमांड से स्थापित करें

एक ऐसी Linux मशीन पर जिसकी देखभाल आप ख़ुद करते हैं, इंस्टॉलर सब कुछ सेट कर देता है और केवल वही पूछता है जो उसे जानने की ज़रूरत है।

इसे चलाने से पहले जाँच लें कि:

- मशीन x86-64 या ARM पर Linux चलाती है, जैसे Ubuntu 24.04 या Debian 13, और आप उस पर `sudo` उपयोग कर सकते हैं।
- मशीन पर कोई और चीज़ पोर्ट 80 और 443 उपयोग नहीं करती। उसके सामने लगे किसी भी फ़ायरवॉल में TCP पोर्ट 80 और 443 तथा UDP पोर्ट 443 खोलें।
- आपके डोमेन का DNS रिकॉर्ड मशीन की ओर इशारा करता है। अगर अभी नहीं करता, तो इंस्टॉल फिर भी पूरा हो जाता है, और Caddy रिकॉर्ड जगह पर आने तक प्रमाणपत्र पाने की कोशिश करता रहता है।
- आपके पास कम से कम एक [साइन-इन प्रोवाइडर](/docs/collaboration/server-access/#sign-in-providers) की जानकारी है, जैसे किसी GitHub OAuth ऐप की client ID और secret। GitHub के लिए callback पता `https://` और आपका डोमेन है, जिसके बाद `/auth/callback/github` आता है।

:::note[बीटा के दौरान]
रिलीज़ कैंडिडेट, Oleafly Server 0.1.1-rc, स्थापित करें ताकि सर्वर Oleafly 0.4.7-rc से मेल खाता हो:

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

नीचे दी गई कमांड 0.1.0 स्थापित करती है, जो पुराना है। अगर आप इमेज किसी दूसरे तरीके से चलाते हैं, जैसे Compose, Coolify, Render या Railway के साथ, तो `ghcr.io/oleafly/oleafly-server:0.1.1-rc` उपयोग करें।
:::

फिर चलाएँ:

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

इंस्टॉलर:

1. मशीन की जाँच करता है, और यह कि पोर्ट 80 और 443 खाली हैं।
2. Docker की जाँच करता है। अगर वह नहीं है, तो इंस्टॉलर Docker के अपने स्क्रिप्ट से उसे स्थापित करने से पहले पूछता है।
3. नवीनतम रिलीज़ की फ़ाइलें [Oleafly Server रिलीज़](https://github.com/Oleafly/oleafly-server/releases) से डाउनलोड करता है और हर एक को रिलीज़ की `SHA256SUMS` से जाँचता है। अगर कोई फ़ाइल मेल नहीं खाती, तो वह कुछ भी बदले बिना रुक जाता है।
4. आपका डोमेन, सर्वर का नाम और लोग कैसे साइन इन करते हैं, पूछता है। वह ईमेल सेट करने और फ़ाइलों को एक S3 बकेट में रखने की भी पेशकश करता है। दोनों वैकल्पिक हैं।
5. एक सारांश दिखाता है और कुछ भी बदलने से पहले पूछता है। फिर वह अपनी फ़ाइलें `/opt/oleafly-server` में लिखता है, आपकी सेटिंग्स `.env` में, जिसे केवल root पढ़ सकता है।
6. Caddy को आगे रखकर सर्वर चालू करता है, तब तक इंतज़ार करता है जब तक आपका डोमेन HTTPS पर उत्तर न देने लगे, और पता तथा सेटअप कोड छापता है।

फिर [पहले एडमिन बनें](#become-the-first-admin)।

आप इंस्टॉलर को किसी भी समय फिर से चला सकते हैं। जब उसे `/opt/oleafly-server` में कोई सर्वर मिलता है, तो वह `.env` को जैसी है वैसी ही रखता है, बाक़ी फ़ाइलें वापस लगाता है और सर्वर को फिर से चालू करता है। इससे ज़्यादातर ख़राब सेटअप ठीक हो जाते हैं।

आपका डेटा Docker वॉल्यूम `oleafly-server_oleafly-data` में रहता है। `/opt/oleafly-server` के अलावा कहीं और स्थापित करने के लिए `OLEAFLY_DIR` सेट करें, जैसे `curl -fsSL https://oleafly.com/server/install.sh | sudo OLEAFLY_DIR=/srv/oleafly sh`, और नीचे दिए गए कमांड में वही फ़ोल्डर उपयोग करें।

### पहले इंस्टॉलर पढ़ें

अगर आपकी संस्था किसी स्क्रिप्ट को shell में पाइप करने की अनुमति नहीं देती, तो `install.sh` और `SHA256SUMS` को [नवीनतम रिलीज़](https://github.com/Oleafly/oleafly-server/releases/latest) से एक फ़ोल्डर में डाउनलोड करें। स्क्रिप्ट की जाँच करें, उसे पढ़ें, फिर चलाएँ:

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

### बिना सवालों के स्थापित करें

किसी स्क्रिप्ट या provisioning टूल के लिए, `--yes` जोड़ें और उत्तरों को environment variables के रूप में पास करें। `OLEAFLY_INSTALL_DOCKER=yes` इंस्टॉलर को Docker जोड़ने देता है अगर वह मौजूद नहीं है।

```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
```

इंस्टॉलर environment में मिली किसी भी सेटिंग को बिना पूछे उपयोग करता है, `--yes` के साथ या बिना। `sudo sh /opt/oleafly-server/install.sh --help` उन सबकी सूची देता है, OpenID Connect, ईमेल और S3 सहित। कमांड लाइन पर टाइप किए गए मान आपके shell इतिहास में पहुँच सकते हैं, इसलिए कोई provisioning टूल secrets अपने ही secret store से पास करे।

### स्थिति, अपडेट और हटाना

- **स्थिति**: `sudo sh /opt/oleafly-server/install.sh status` दिखाता है कि सर्वर चल रहा है या नहीं, और आपका डोमेन वैध प्रमाणपत्र के साथ HTTPS पर उत्तर देता है या नहीं।
- **अपडेट**: पहले बैकअप लें, जैसा [अपडेट करना](/docs/collaboration/server-operations/#updating) समझाता है। फिर नीचे दी गई कमांड चलाएँ। वह नवीनतम रिलीज़ की फ़ाइलें और इमेज डाउनलोड करती है, `.env` को बनाए रखती है, सर्वर को फिर से चालू करती है और तब तक इंतज़ार करती है जब तक वह उत्तर न देने लगे। जो लोग जुड़े हुए हैं वे अपने आप फिर जुड़ जाते हैं। इंस्टॉलर कभी किसी सर्वर को किसी पुरानी रिलीज़ पर नहीं ले जाता।

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

- **हटाना**: `sudo sh /opt/oleafly-server/install.sh uninstall` कंटेनरों को रोककर हटा देता है। आपका डेटा और `.env` बने रहते हैं जब तक कि वह पूछने पर आप `delete` न टाइप करें। उन्हें हटाने से सर्वर पर हर साझा प्रोजेक्ट, हर खाता और सुरक्षा लॉग हट जाता है। लोग अपने कंप्यूटर पर प्रोजेक्ट की अपनी प्रतियाँ रखते हैं।

अगर इंस्टॉलर किसी ऐसी समस्या से रुक जाए जिसे आप ठीक नहीं कर सकते, तो जो उसने छापा था उसके साथ उसे [रिपोर्ट करें](https://github.com/Oleafly/oleafly-server/issues/new/choose)।

## Docker Compose स्वयं

यह सेटअप दो कंटेनर चलाता है। `oleafly-server` सर्वर है, और केवल दूसरे कंटेनर ही उस तक पहुँच सकते हैं। `caddy` Let's Encrypt से प्रमाणपत्र लेता है, पोर्ट 80 और 443 पर HTTPS देता है, और अनुरोधों को सर्वर तक पास करता है, लाइव कनेक्शन सहित।

1. [Docker के निर्देशों](https://docs.docker.com/engine/install/) का पालन करके Docker Engine और Compose प्लगइन स्थापित करें।
2. अपने डोमेन का DNS रिकॉर्ड मशीन की ओर इशारा करें। उसके सामने लगे किसी भी फ़ायरवॉल में TCP पोर्ट 80 और 443 तथा UDP पोर्ट 443 खोलें। Caddy को प्रमाणपत्र पाने के लिए पोर्ट 80 चाहिए।
3. सर्वर के लिए एक फ़ोल्डर बनाएँ, उसमें नवीनतम रिलीज़ की फ़ाइलें डाउनलोड करें, उन्हें जाँचें, और अपनी सेटिंग्स फ़ाइल बनाएँ:

   ```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` को `sudoedit .env` से संपादित करें। `OLEAFLY_DOMAIN` को `https://` के बिना अपने डोमेन पर सेट करें, `OLEAFLY_SERVER_NAME` सेट करें, और कम से कम एक [साइन-इन प्रोवाइडर](/docs/collaboration/server-access/#sign-in-providers) भरें। जिन provider पंक्तियों का आप उपयोग नहीं करते उन्हें खाली छोड़ दें। किसी मान में `$` या `#` हो तो उसे single quotes में रखें।
5. इसे चालू करें। पहली बार चालू होने पर सर्वर इमेज, `ghcr.io/oleafly/oleafly-server`, रिलीज़ के संस्करण पर डाउनलोड होती है।

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

6. जाँचें कि वह उत्तर देता है। यह `200` छापता है:

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

7. [पहले एडमिन बनें](#become-the-first-admin)। सेटअप कोड लॉग में है:

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

आपका डेटा Docker वॉल्यूम `oleafly-server_oleafly-data` में रहता है। Caddy अपने प्रमाणपत्र `oleafly-server_caddy-data` में रखता है।

Docker पोर्ट 80 और 443 ख़ुद खोलता है, तब भी जब `ufw` जैसा कोई होस्ट फ़ायरवॉल चालू हो। Caddy को यही चाहिए। `oleafly-server` सेवा में `ports:` प्रविष्टि न जोड़ें। मशीन से ही सर्वर तक पहुँचने के लिए, उसे `127.0.0.1:8080:8080` के रूप में publish करें ताकि वह नेटवर्क पर न आए।

अगर आप `Caddyfile` बदलते हैं, तो `sudo docker compose up -d --force-recreate caddy` चलाएँ। बाद में अपडेट करने के लिए, नई रिलीज़ की फ़ाइलें उसी तरह डाउनलोड करें और `sudo docker compose up -d` फिर से चलाएँ।

### .env से secrets दूर रखें

सात सेटिंग्स secrets रख सकती हैं: `OLEAFLY_SETUP_CODE`, `OLEAFLY_GITHUB_CLIENT_SECRET`, `OLEAFLY_OIDC_<NAME>_CLIENT_SECRET`, `OLEAFLY_SMTP_URL`, `OLEAFLY_BLOB_STORE`, `OLEAFLY_S3_ACCESS_KEY_ID` और `OLEAFLY_S3_SECRET_ACCESS_KEY`। हर एक का एक `_FILE` संस्करण भी होता है जो मान रखने वाली फ़ाइल का नाम बताता है। दोनों में से एक सेट करें, दोनों नहीं।

उदाहरण के लिए, GitHub client secret को Docker secret के रूप में पास करने के लिए, उसे `docker-compose.yml` के बगल में `secrets/github_client_secret` में सहेजें, सर्वर के यूज़र (ID 10001) को उसे पढ़ने दें, और `.env` से `OLEAFLY_GITHUB_CLIENT_SECRET` पंक्ति हटा दें:

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

फिर `docker-compose.yml` के बगल में `docker-compose.override.yml` बनाएँ। Compose उसे अपने आप पढ़ता है, और इंस्टॉलर दूसरी फ़ाइलें अपडेट करते समय उसे नहीं छेड़ता।

```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` फिर से चलाएँ।

## Coolify

Coolify सर्वर के आगे अपना ही प्रॉक्सी रखता है और प्रमाणपत्र लेता है, इसलिए इस सेटअप में कोई Caddy नहीं है। Coolify सर्वर को Oleafly रिपॉज़िटरी से बिल्ड कर सकता है, या [प्रकाशित इमेज](#deploy-the-published-image) चला सकता है, जिससे बिल्ड छूट जाता है।

शुरू करने से पहले, अपने डोमेन का DNS रिकॉर्ड, जैसे `collab.example.org`, Coolify सर्वर की ओर इशारा करें। फिर [GitHub](/docs/collaboration/server-access/#github) में बताए अनुसार GitHub OAuth ऐप बनाएँ, callback पते `https://collab.example.org/auth/callback/github` के साथ। उसकी client ID और secret हाथ में रखें।

### रिपॉज़िटरी से बिल्ड करें

1. अपने Coolify प्रोजेक्ट में **+ New** चुनें, फिर **Public Repository**, और `https://github.com/Oleafly/Oleafly` भरें। ब्रांच `main` रखें।
2. **Build Pack** को **Docker Compose** पर, **Base Directory** को `/` पर और **Docker Compose Location** को `/deploy/server/docker-compose.coolify.yml` पर सेट करें, फिर **Continue** चुनें।
3. **Advanced › Build** के नीचे, **Build arguments** को **Managed manually in Dockerfile** पर सेट करें। सर्वर की इमेज को किसी build argument की ज़रूरत नहीं है। स्वचालित छोड़ने पर Coolify हर variable, secrets सहित, इमेज के build इतिहास में लिख देता है।
4. **General** के नीचे, `oleafly-server` का डोमेन `https://collab.example.org:8080` पर सेट करें और सहेजें। `:8080`, Coolify के प्रॉक्सी को बताता है कि सर्वर किस पोर्ट पर सुनता है। लोग अब भी सामान्य HTTPS पोर्ट पर जुड़ते हैं, और Coolify आपके लिए `OLEAFLY_PUBLIC_URL` को `https://collab.example.org` पर सेट कर देता है।
5. **Environment Variables** के नीचे, `OLEAFLY_SERVER_NAME` भरें, जिसे Coolify आवश्यक दिखाता है, फिर `OLEAFLY_GITHUB_CLIENT_ID` और `OLEAFLY_GITHUB_CLIENT_SECRET`। जिन variables का आप उपयोग नहीं करते उन्हें खाली छोड़ दें।
6. **Deploy** चुनें। पहला बिल्ड सर्वर कंपाइल करता है और कुछ मिनट लेता है। पूरा होने पर Coolify संसाधन को चलता हुआ और स्वस्थ दिखाता है।
7. किसी ब्राउज़र में `https://collab.example.org/healthz` खोलें। वह `{"status":"ok"}` दिखाता है।
8. **Logs** खोलें, `oleafly-server` कंटेनर चुनें, और `Setup code:` से शुरू होने वाली नवीनतम पंक्ति से कोड कॉपी करें।
9. उस कोड के साथ [पहले एडमिन बनें](#become-the-first-admin)।

अगर सर्वर शुरू नहीं होता, तो उसका लॉग उस सेटिंग का नाम बताता है जिसका वह उपयोग नहीं कर पा रहा। जब वह कहे कि `OLEAFLY_PUBLIC_URL` सेट नहीं है, तो चरण 4 छूट गया है। `http://` से शुरू होने वाला डोमेन अस्वीकार कर दिया जाता है, क्योंकि सर्वर को HTTPS चाहिए।

अगर Cloudflare, Coolify के आगे है, क्योंकि आपका DNS रिकॉर्ड Cloudflare के प्रॉक्सी से गुज़रता है या कोई टनल Coolify के प्रॉक्सी तक जाता है, तो `OLEAFLY_PROXY_HOPS` को `2` पर सेट करें। इसके बिना सुरक्षा लॉग हर किसी के लिए प्रॉक्सी का पता दिखाता है, और सब एक ही साइन-इन सीमा साझा करते हैं।

Coolify फ़ाइल में GitHub और `UNIVERSITY` नाम के एक OpenID Connect प्रोवाइडर की जगह है। `OLEAFLY_OIDC_UNIVERSITY_LABEL` को उस पाठ पर सेट करें जो लोगों को दिखे, जैसे `GitLab`। उसका callback पता `/auth/callback/university` पर ख़त्म होता है। और प्रोवाइडरों के लिए, फ़ाइल की अपनी प्रति के साथ किसी fork से deploy करें।

डेटा एक Docker वॉल्यूम में रहता है जिसका नाम `oleafly-data` पर ख़त्म होता है। उसे `docker volume ls --filter name=oleafly-data` से खोजें। इमेज में कोई shell नहीं है, इसलिए Coolify का **Terminal** सर्वर के कंटेनर में shell नहीं खोल सकता। लॉग और health check हमेशा की तरह काम करते हैं।

### प्रकाशित इमेज deploy करें

प्रकाशित इमेज चलाने से बिल्ड छूट जाता है, जो एक छोटे Coolify सर्वर के लिए ठीक है। ऊपर के चरणों का पालन करें, दो बदलावों के साथ। चरण 2 में, **Docker Compose Location** को `/deploy/server/docker-compose.coolify-image.yml` पर सेट करें। चरण 3 छोड़ दें, क्योंकि कुछ भी बिल्ड नहीं होता। फ़ाइल एक रिलीज़ श्रृंखला का पालन करती है, इसलिए हर **Redeploy** उसमें सबसे नई रिलीज़ खींचता है।

## Render

[Render पर deploy करें](https://render.com/deploy?repo=https://github.com/Oleafly/Oleafly), Oleafly रिपॉज़िटरी में मौजूद Blueprint को पढ़ता है। वह प्रकाशित इमेज से एक web service बनाता है, डेटा फ़ोल्डर के लिए 1 GB डिस्क के साथ। Render डिस्क केवल सशुल्क instance प्रकारों से जोड़ता है, इसलिए सेवा सबसे छोटे सशुल्क instance पर शुरू होती है, Render के Oregon क्षेत्र में। किसी दूसरे क्षेत्र के लिए, `render.yaml` में `region` सेट करके किसी fork से deploy करें।

1. लिंक खोलें और Render में साइन इन करें।
2. Render, `OLEAFLY_SERVER_NAME` और GitHub client ID तथा secret माँगता है। नाम भरें और GitHub फ़ील्ड अभी के लिए खाली छोड़ दें। उनका callback पता सेवा के पते पर निर्भर करता है, जो आपके पास अभी नहीं है।
3. **Deploy Blueprint** चुनें। सेवा चालू होते ही उसका पेज उसका पता दिखाता है, जैसे `https://oleafly-server.onrender.com`। Blueprint `OLEAFLY_PUBLIC_URL` को उसी पते पर सेट करता है।
4. [GitHub](/docs/collaboration/server-access/#github) में बताए अनुसार GitHub OAuth ऐप बनाएँ, उस पते के बाद `/auth/callback/github` जोड़कर callback पता बनाएँ। सेवा के **Environment** के नीचे client ID और secret जोड़ें। Render उनके साथ सर्वर को फिर से चालू करता है।
5. सेवा के **Logs** में नवीनतम `Setup code:` पंक्ति खोजें और [पहले एडमिन बनें](#become-the-first-admin)।

अगर आप सेवा को अपना ख़ुद का डोमेन देते हैं, तो **Environment** के नीचे `OLEAFLY_PUBLIC_URL` को उसी पर सेट करें और GitHub पर callback पता उससे मिलाने के लिए बदलें।

डिस्क की वजह से, Render नया सर्वर चालू करने से पहले चल रहे सर्वर को रोकता है, इसलिए हर deploy सर्वर को कुछ सेकंड के लिए हटा देता है। Oleafly अपने आप फिर जुड़ जाता है।

## Railway

Railway प्रकाशित इमेज चलाता है, डेटा फ़ोल्डर के लिए एक वॉल्यूम के साथ।

1. एक Railway प्रोजेक्ट में **+ New** चुनें, फिर **Docker Image**, और `ghcr.io/oleafly/oleafly-server:latest` भरें। अपग्रेड कब करें यह चुनने के लिए, इसकी जगह [रिलीज़ पेज](https://github.com/Oleafly/Oleafly/releases) से किसी रिलीज़ का अपना tag उपयोग करें। Railway पहला deploy तुरंत शुरू कर सकता है। वह `OLEAFLY_PUBLIC_URL is not set` के साथ रुकता है, जो इस बिंदु पर सामान्य है।
2. सेवा खोलें। **Settings › Networking** के नीचे **Generate Domain** चुनें और पोर्ट `8080` भरें। Railway पता दिखाता है, जैसे `oleafly-server-production.up.railway.app`।
3. **Settings › Deploy** के नीचे, **Healthcheck Path** को `/readyz` पर सेट करें।
4. प्रोजेक्ट कैनवास पर right-click करें, एक वॉल्यूम जोड़ें, उसे सर्वर की सेवा से जोड़ें और उसका mount पथ `/data` पर सेट करें।
5. **Variables** के नीचे, **Raw Editor** खोलें और यह पंक्तियाँ अपने सर्वर के नाम के साथ चिपकाएँ। GitHub मानों के लिए, [GitHub](/docs/collaboration/server-access/#github) का पालन करें। Callback पता चरण 2 का आपका पता है जिसके आगे `https://` और पीछे `/auth/callback/github` है।

   ```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 वॉल्यूम को root के रूप में mount करता है। `RAILWAY_RUN_UID=0` सर्वर को root के रूप में चलाता है ताकि वह वॉल्यूम में लिख सके।

6. बदलाव deploy करें। सेवा के **Deploy Logs** में नवीनतम `Setup code:` पंक्ति खोजें और [पहले एडमिन बनें](#become-the-first-admin)।

## Docker के बिना Linux

Docker के बिना किसी मशीन पर, सर्वर systemd के नीचे एक अकेली प्रोग्राम के रूप में चलता है, HTTPS के लिए आगे Caddy के साथ।

### सर्वर डाउनलोड करें

[रिलीज़ पेज](https://github.com/Oleafly/Oleafly/releases) पर हर सर्वर रिलीज़ में x86-64 और ARM के लिए पहले से बिल्ड हुई प्रोग्राम होती है, और जाँच के लिए एक `SHA256SUMS` फ़ाइल। प्रोग्राम को स्थापित करने के लिए किसी और चीज़ की ज़रूरत नहीं है।

अपनी मशीन के लिए आर्काइव डाउनलोड करें, जो `x86_64-unknown-linux-musl.tar.gz` या `aarch64-unknown-linux-musl.tar.gz` पर ख़त्म होता है, और `SHA256SUMS` एक फ़ोल्डर में। फिर जाँच कर उसे स्थापित करें। ARM मशीन पर, `x86_64` की जगह `aarch64` उपयोग करें:

```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 स्थापित होने पर, `gh attestation verify oleafly-server-*-x86_64-unknown-linux-musl.tar.gz --repo Oleafly/Oleafly` यह भी जाँचता है कि GitHub ने आर्काइव Oleafly रिपॉज़िटरी से बिल्ड किया है। आर्काइव में systemd यूनिट, `oleafly-server.service`, शामिल है।

इसकी जगह प्रोग्राम ख़ुद बिल्ड करने के लिए, Docker वाले किसी भी कंप्यूटर पर Oleafly रिपॉज़िटरी के क्लोन से यह चलाएँ। ARM सर्वर के लिए `--platform linux/arm64` उपयोग करें।

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

यह `dist/oleafly-server` लिखता है। उसे सर्वर पर `/usr/local/bin/oleafly-server` में कॉपी करें और executable बना दें।

### systemd के साथ चलाएँ

1. सेटिंग्स फ़ाइल बनाएँ। केवल root उसे पढ़ सकता है:

   ```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
   ```

   हर पंक्ति में एक सेटिंग रखें। `OLEAFLY_BIND=127.0.0.1:8080` सर्वर को नेटवर्क से हटाकर रखता है ताकि केवल Caddy उस तक पहुँच सके। `OLEAFLY_DATA_DIR` सेट न करें, क्योंकि यूनिट उसे सेट करती है।

   ```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. खोले गए आर्काइव से, या रिपॉज़िटरी के क्लोन में `deploy/server` से, यूनिट स्थापित कर चालू करें। फिर सेटअप कोड खोजें:

   ```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'
   ```

यूनिट सर्वर को एक ऐसे यूज़र के रूप में चलाती है जिसे systemd उसके लिए बनाता है, बाक़ी सिस्टम के केवल-पढ़ने-योग्य दृश्य के साथ। लिखने की एकमात्र जगह `/var/lib/oleafly-server` है, जहाँ वह अपना डेटा रखता है। डिस्क पर वह फ़ोल्डर `/var/lib/private/oleafly-server` है।

Client secret को सेटिंग्स फ़ाइल से बाहर रखने के लिए, systemd credential उपयोग करें। Secret को mode 600 के साथ `/etc/oleafly-server/github-client-secret` में सहेजें, सेटिंग्स फ़ाइल से `OLEAFLY_GITHUB_CLIENT_SECRET` पंक्ति हटाएँ, `sudo systemctl edit oleafly-server` चलाएँ, और जोड़ें:

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

फिर `sudo systemctl restart oleafly-server` चलाएँ।

### आगे HTTPS लगाएँ

Caddy को [अपने वितरण के लिए उसके निर्देशों](https://caddyserver.com/docs/install) के साथ स्थापित करें। `/etc/caddy/Caddyfile` को इन पंक्तियों से बदलें और `sudo systemctl reload caddy` चलाएँ। Caddy प्रमाणपत्र लेता है और लाइव कनेक्शनों को पास करता है।

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

nginx या Apache के लिए, या उस web server के लिए जो आपका विश्वविद्यालय पहले से चलाता है, [रिवर्स प्रॉक्सी के पीछे](/docs/collaboration/server-operations/#behind-a-reverse-proxy) पढ़ें।

## बिना सार्वजनिक पता के

अगर मशीन का कोई सार्वजनिक पता नहीं है, जैसे विश्वविद्यालय फ़ायरवॉल के पीछे आपकी प्रयोगशाला का कोई कंप्यूटर, तो Cloudflare Tunnel उसे पहुँच योग्य बना सकता है। आपको एक Cloudflare खाता चाहिए जिस पर आपका डोमेन हो। Cloudflare hostname के लिए HTTPS संभालता है, इसलिए अनुरोध आपकी मशीन तक पहुँचने से पहले Cloudflare के नेटवर्क पर decrypt हो जाते हैं। Cloudflare को उन पक्षों में गिनें जो आपके सर्वर तक का traffic पढ़ सकते हैं।

1. [Docker Compose स्वयं](#docker-compose-by-hand) के चरणों का, `.env` संपादित करने तक, पालन करें। `OLEAFLY_DOMAIN` को उस hostname पर सेट करें जिसका आप उपयोग करेंगे, जैसे `collab.example.org`। एक-कमांड इंस्टॉलर यहाँ उपयुक्त नहीं है, क्योंकि वह Caddy चालू करता है।
2. केवल सर्वर चालू करें। Caddy यहाँ ज़रूरी नहीं है:

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

3. Cloudflare dashboard में **Networking › Tunnels** पर जाएँ, **Create Tunnel** चुनें, उसे एक नाम दें, और **Create Tunnel** फिर से चुनें। जो install कमांड वह दिखाता है उसमें से token कॉपी करें।
4. टनल को सर्वर के बगल में चालू करें। `read` कमांड आपके token चिपकाने का इंतज़ार करता है और उसे नहीं दिखाता:

   ```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. वापस dashboard में, टनल खोलें। **Routes** के नीचे **Add route** चुनें, फिर **Published application**। **Hostname** के नीचे, subdomain भरें और अपना डोमेन चुनें। **Service URL** को `http://oleafly-server:8080` पर सेट करें और **Add route** चुनें।
6. जाँचें कि वह `https://collab.example.org/healthz` पर उत्तर देता है, फिर [पहले एडमिन बनें](#become-the-first-admin)।

Docker के बिना किसी मशीन पर, `cloudflared` को [Cloudflare के पैकेज रिपॉज़िटरी](https://pkg.cloudflare.com/) से स्थापित करें, `sudo cloudflared service install` के बाद token देकर चलाएँ, और **Service URL** को `http://127.0.0.1:8080` पर सेट करें।

Cloudflare लाइव कनेक्शनों को पास करता है और `X-Forwarded-For` में विज़िटर का पता आख़िर में रखता है, इसलिए `OLEAFLY_BEHIND_PROXY=true` बनाए रखें। जब टनल सीधे सर्वर तक न जाकर किसी दूसरे प्रॉक्सी तक जाए, जैसे Coolify का, तो `OLEAFLY_PROXY_HOPS=2` भी सेट करें। Cloudflare अपनी Free और Pro योजनाओं पर 100 MB से बड़े अनुरोध अस्वीकार करता है, इसलिए `OLEAFLY_MAX_PROJECT_MB` को 100 या उससे कम पर सेट करें, वरना बड़े प्रोजेक्ट अपलोड नहीं हो पाते। सर्वर के आगे Cloudflare Access न लगाएँ, क्योंकि Oleafly उसके लॉगिन पेज से आगे नहीं जा सकता।

जब आप बाद में सर्वर अपडेट करें, तो नई रिलीज़ की फ़ाइलें डाउनलोड करें और सेवा का नाम देकर चलाएँ ताकि Caddy बाहर रहे: `sudo docker compose up -d oleafly-server`।

## पहले एडमिन बनें

नए सर्वर का कोई एडमिन नहीं होता। जब तक कोई सेटअप पूरा नहीं करता, सर्वर हर बार चालू होने पर एक नया one-time सेटअप कोड बनाता है और उसे अपने लॉग में लिखता है।

1. लॉग में `Setup code:` से शुरू होने वाली नवीनतम पंक्ति खोजें:
   - एक-कमांड स्थापना: इंस्टॉलर पूरा होने पर उसे छापता है। फिर से देखने के लिए, `cd /opt/oleafly-server && sudo docker compose logs oleafly-server | grep 'Setup code'` चलाएँ
   - Docker Compose स्वयं: सर्वर के फ़ोल्डर में `sudo docker compose logs oleafly-server | grep 'Setup code'`
   - Coolify: `oleafly-server` सेवा के लॉग
   - systemd: `sudo journalctl -u oleafly-server | grep 'Setup code'`
2. Oleafly में, **Settings → Collaboration** खोलें, **Add server** चुनें, और अपने सर्वर का पता भरें। Oleafly देखता है कि सर्वर को सेटअप चाहिए और **Setup code** माँगता है।
3. कोड भरें और अपने द्वारा कॉन्फ़िगर किसी भी provider से साइन इन करें। आप सर्वर के एडमिन बन जाते हैं, और कोड काम करना बंद कर देता है।

जिसके पास आपसे पहले कोड पहुँच जाए, वह ख़ुद को एडमिन बना सकता है, इसलिए उसे केवल Oleafly में ही कभी चिपकाएँ।

आप `OLEAFLY_SETUP_CODE` से कोड ख़ुद भी चुन सकते हैं: कम से कम 12 अक्षर या अंक, चाहें तो dashes या spaces के साथ। तब सर्वर उसे कभी नहीं छापता। लॉग केवल `Setup code: set by OLEAFLY_SETUP_CODE` कहता है, और आप वही मान भरते हैं जो आपने सेट किया था। सेटअप पूरा होने पर उसे अपनी सेटिंग्स से हटा दें।

अगला क़दम, लोगों को अंदर आने दें। [साइन-इन और पहुँच](/docs/collaboration/server-access/#access-rules) समझाता है कि कैसे।

## सर्वर की जाँच करें

- एक-कमांड स्थापना के साथ, `sudo sh /opt/oleafly-server/install.sh status` एक ही बार में कंटेनर और HTTPS जाँचता है।
- सर्वर प्रक्रिया चलते समय `https://collab.example.org/healthz`, `200` उत्तर देता है।
- `/readyz` केवल तब `200` उत्तर देता है जब सर्वर अपने डेटाबेस और अपने डेटा फ़ोल्डर में लिख सकता है। जब नहीं कर सकता, जैसे भरी हुई डिस्क पर, वह `503` उत्तर देता है और जो विफल हुआ उसका नाम बताता है, `database` या `storage`।
- Docker इमेज ख़ुद `/readyz` जाँचती है, इसलिए `docker ps` और Coolify एक अस्वस्थ सर्वर दिखाते हैं, न कि ऐसा चलता हुआ सर्वर जो कुछ भी सहेज नहीं सकता।
- Oleafly में, **Settings → Collaboration** के नीचे **Test connection** पता, HTTPS, संस्करण, लाइव कनेक्शन, साइन-इन विकल्प और सर्वर की घड़ी जाँचता है। [एडमिन कंसोल](/docs/collaboration/server-access/#admin-console) में **Connection checks** वही जाँचेँ चलाता है।
