# स्टोरेज, बैकअप और सीमाएँ

Oleafly Server की हर सेटिंग, फ़ाइलों को डिस्क पर या S3 बकेट में रखना, कंपाइल की गई PDF, प्रॉक्सी के पीछे चलाना, एक नेटवर्क पर क्लास के लिए और हर खाते के लिए सीमाएँ, लॉग, बैकअप, रीस्टोर और अपडेट।

यह पेज Oleafly Server को रोज़ाना चलाने के बारे में है। इसे इंस्टॉल करने के लिए [कोलैबोरेशन सर्वर चलाएँ](/docs/collaboration/server/) से शुरू करें।

## सेटिंग्स

सर्वर अपनी सेटिंग्स environment variables से पढ़ता है। जो variable सेट है लेकिन खाली है, उसे सेट नहीं माना जाता। अगर कोई सेटिंग गायब हो या गलत रूप में हो, तो सर्वर शुरू नहीं होता, और उसका लॉग बता देता है कि कौन सी।

| Variable | यह क्या करता है | डिफ़ॉल्ट |
| --- | --- | --- |
| `OLEAFLY_PUBLIC_URL` | वह HTTPS पता जो लोग Oleafly में डालते हैं। इसमें पाथ शामिल हो सकता है, जैसे `https://www.cs.example.edu/oleafly`। ज़रूरी है। Compose और Coolify फ़ाइलें इसे आपके लिए सेट कर देती हैं। | कोई नहीं |
| `OLEAFLY_BIND` | वह पता और पोर्ट जिन पर सर्वर सुनता है। | `0.0.0.0:8080` |
| `OLEAFLY_DATA_DIR` | डेटाबेस और संग्रहीत फ़ाइलों के लिए फ़ोल्डर। | `/data` |
| `OLEAFLY_SERVER_NAME` | वह नाम जो लोग Oleafly में देखते हैं, जैसे `Smith Lab`। | `Oleafly Server` |
| `OLEAFLY_SERVER_ICON_URL` | नाम के बगल में दिखने वाले वर्गाकार इमेज का HTTPS पता। | कोई नहीं |
| `OLEAFLY_SETUP_CODE` | आपका अपना एक बार इस्तेमाल होने वाला सेटअप कोड: कम से कम 12 अक्षर या अंक, चाहें तो डैश या स्पेस के साथ। इसके बिना सर्वर खुद एक बना देता है। | अपने आप बनता है |
| `OLEAFLY_GITHUB_CLIENT_ID`, `OLEAFLY_GITHUB_CLIENT_SECRET` | GitHub से साइन-इन चालू करें। | बंद |
| `OLEAFLY_GITHUB_URL` | GitHub Enterprise Server का पता। | `https://github.com` |
| `OLEAFLY_GITHUB_API_URL` | GitHub API का पता, अगर आपका सामान्य से अलग हो। | `https://api.github.com`, या `OLEAFLY_GITHUB_URL` के तहत `/api/v3` |
| `OLEAFLY_GITHUB_LABEL` | GitHub साइन-इन बटन पर लिखा टेक्स्ट। | `GitHub` |
| `OLEAFLY_OIDC_<NAME>_ISSUER`, `OLEAFLY_OIDC_<NAME>_CLIENT_ID`, `OLEAFLY_OIDC_<NAME>_CLIENT_SECRET` | `<NAME>` नाम का OpenID Connect प्रोवाइडर चालू करें। | बंद |
| `OLEAFLY_OIDC_<NAME>_LABEL` | उसके साइन-इन बटन पर लिखा टेक्स्ट, जैसे `University login`। | `<NAME>` |
| `OLEAFLY_OIDC_<NAME>_TRUST_EMAIL` | इस प्रोवाइडर से आने वाले हर ईमेल पते को सत्यापित मानें। पहले [सत्यापित ईमेल पते](/docs/collaboration/server-access/#verified-email-addresses) पढ़ें। | `false` |
| `OLEAFLY_SMTP_URL`, `OLEAFLY_MAIL_FROM` | ईमेल। [ईमेल](/docs/collaboration/server-access/#email) पढ़ें। | बंद |
| `OLEAFLY_OPEN_SIGNUP` | आपके किसी प्रोवाइडर से साइन इन करने वाले हर व्यक्ति को सदस्य के रूप में खाता दें। [खुला साइन-अप](/docs/collaboration/server-access/#open-sign-up) पढ़ें। | `false` |
| `OLEAFLY_WEB` | ब्राउज़र से एक्सेस चालू करें। [ब्राउज़र से एक्सेस](/docs/collaboration/server-access/#browser-access) पढ़ें। | `false` |
| `OLEAFLY_BLOB_STORE` | फ़िगर और PDF जैसी फ़ाइलें कहाँ रखी जाती हैं। `fs` उन्हें `OLEAFLY_DATA_DIR` में रखता है। `s3://lab-bucket` या `s3://lab-bucket/oleafly` जैसा पता उन्हें बकेट में रखता है। | `fs` |
| `OLEAFLY_S3_ENDPOINT` | Amazon S3 के अलावा किसी S3-compatible स्टोर का पता, जैसे MinIO या Cloudflare R2। Amazon S3 के लिए इसे खाली छोड़ दें। | Amazon S3 |
| `OLEAFLY_S3_REGION` | बकेट का क्षेत्र। | `us-east-1` |
| `OLEAFLY_S3_ACCESS_KEY_ID`, `OLEAFLY_S3_SECRET_ACCESS_KEY` | वह कुंजी जो सर्वर बकेट के लिए इस्तेमाल करता है। `s3://` पते के साथ ज़रूरी है। | कोई नहीं |
| `OLEAFLY_MAX_PROJECT_MB` | सबसे बड़ा प्रोजेक्ट जो सर्वर स्वीकार करता है, मेगाबाइट में। | `200` |
| `OLEAFLY_MAX_FILE_MB` | सबसे बड़ी एकल फ़ाइल, मेगाबाइट में। | `50` |
| `OLEAFLY_MAX_MEMBERS_PER_PROJECT` | एक प्रोजेक्ट पर सबसे ज़्यादा कितने लोग। | `20` |
| `OLEAFLY_ACCOUNT_STORAGE_MB` | एक खाते के अपने प्रोजेक्ट सबसे ज़्यादा कितना संग्रहीत कर सकते हैं, मेगाबाइट में। [हर खाते की सीमाएँ](#limits-per-account) पढ़ें। | कोई सीमा नहीं, या खुले साइन-अप के साथ `100` |
| `OLEAFLY_MAX_PROJECTS_PER_ACCOUNT` | एक खाता सबसे ज़्यादा कितने साझा प्रोजेक्टों का मालिक हो सकता है। | कोई सीमा नहीं, या खुले साइन-अप के साथ `50` |
| `OLEAFLY_UPLOADS_PER_HOUR` | एक खाता एक घंटे में कितने फ़ाइल और स्नैपशॉट अपलोड कर सकता है। | कोई सीमा नहीं, या खुले साइन-अप के साथ `300` |
| `OLEAFLY_SIGN_IN_BURST` | एक नेटवर्क पता एक बार में कितने साइन-इन अनुरोध कर सकता है। एक साइन-इन में करीब छह लगते हैं, इसलिए डिफ़ॉल्ट एक ही पते से 50 लोगों के एक साथ साइन-इन को कवर करता है। | `300` |
| `OLEAFLY_SIGN_IN_PER_MINUTE` | उस burst के बाद हर मिनट एक नेटवर्क पते को कितने साइन-इन अनुरोध वापस मिलते हैं। | `120` |
| `OLEAFLY_EMAIL_LINKS_PER_IP` | 15 मिनट में सर्वर एक नेटवर्क पते के लोगों को कितने साइन-इन ईमेल भेजता है। | `100` |
| `OLEAFLY_EMAIL_LINKS_PER_ADDRESS` | एक ईमेल पते को 15 मिनट में कितने साइन-इन ईमेल मिल सकते हैं। यह `OLEAFLY_EMAIL_LINKS_PER_IP` से ज़्यादा नहीं हो सकता। | `3` |
| `OLEAFLY_DEVICE_CODES_PER_IP` | एक नेटवर्क पते के लोग 10 मिनट में कितने साइन-इन कोड माँग सकते हैं। | `100` |
| `OLEAFLY_SNAPSHOT_MEMORY_MB` | प्रोजेक्ट स्नैपशॉट बनाने में सर्वर कितनी मेमोरी, मेगाबाइट में, इस्तेमाल कर सकता है। | कंटेनर की मेमोरी सीमा का आधा, या सीमा न होने पर `1024` |
| `OLEAFLY_BEHIND_PROXY` | हर व्यक्ति का पता उस `X-Forwarded-For` हेडर से लें जो आपका प्रॉक्सी जोड़ता है। Compose, Coolify और Render फ़ाइलें इसे चालू करती हैं। | `false` |
| `OLEAFLY_PROXY_HOPS` | हर अनुरोध सर्वर तक पहुँचने से पहले कितने प्रॉक्सी से गुज़रता है। इसे `OLEAFLY_BEHIND_PROXY=true` चाहिए। | `1` |
| `OLEAFLY_LOG_LEVEL` | सर्वर कितना लॉग करता है: `error`, `warn`, `info`, `debug` या `trace`। जब तक आप `debug` या `trace` न चुनें, सर्वर के इस्तेमाल की लाइब्रेरीज़ केवल चेतावनियाँ लॉग करती हैं। | `info` |
| `OLEAFLY_SECURITY_LOG_DAYS` | सिक्योरिटी लॉग प्रविष्टियाँ, प्रोजेक्ट एक्सेस लॉग प्रविष्टियाँ और जवाब दिए गए या समय से बीत चुके अतिथि निमंत्रण कितने दिन रखने हैं। | `365` |
| `OLEAFLY_ARCHIVE_DAYS` | मालिक के साझा करना बंद करने के बाद प्रोजेक्ट को कितने दिन रखना है। | `30` |
| `OLEAFLY_POLL_HOLD_SECONDS` | जब कोई बदलाव बाकी न हो, तो सर्वर एक long-polling अनुरोध को 1 से 40 सेकंड तक कितनी देर खुला रखता है। इसे सर्वर के आगे लगे किसी भी प्रॉक्सी के idle timeout से कुछ सेकंड कम रखें। | `25` |

Compose की `.env` फ़ाइल में, अगर किसी वैल्यू में `$` या `#` हो तो उसे सिंगल कोट्स में डालें। रहस्य रखने वाली सेटिंग्स फ़ाइलों से भी पढ़ी जा सकती हैं। [.env से रहस्य दूर रखें](/docs/collaboration/server/#keep-secrets-out-of-env) पढ़ें।

## स्टोरेज

डिफ़ॉल्ट रूप से सर्वर सब कुछ `OLEAFLY_DATA_DIR` में रखता है: डेटाबेस, वे फ़ाइलें जो लोग साझा करते हैं, और प्रोजेक्ट स्नैपशॉट। स्नैपशॉट हर प्रोजेक्ट की सहेजी गई प्रतियाँ हैं जिनसे लोग जल्दी जुड़कर बाकी काम पकड़ सकते हैं।

### बकेट में फ़ाइलें

सर्वर फ़ाइलों और स्नैपशॉट को इसके बजाय Amazon S3 में, या S3-compatible API वाले किसी और स्टोर में रख सकता है, जैसे MinIO या Cloudflare R2। दोनों ही स्थितियों में डेटाबेस `OLEAFLY_DATA_DIR` में ही रहता है, इसलिए सर्वर को अपना डेटा फ़ोल्डर अब भी चाहिए।

1. एक बकेट बनाएँ और उसका सार्वजनिक एक्सेस ब्लॉक कर दें।
2. ऐसी कुंजी बनाएँ जो उस बकेट में ऑब्जेक्ट पढ़, लिख और मिटा सके और और कुछ नहीं। Amazon S3 पर इसका मतलब है `arn:aws:s3:::lab-bucket/*` पर `s3:GetObject`, `s3:PutObject` और `s3:DeleteObject`, या फ़ोल्डर इस्तेमाल करते हों तो `arn:aws:s3:::lab-bucket/oleafly/*` पर।
3. वेरिएबल्स सेट करें, जैसे `.env` में:

   ```sh
   OLEAFLY_BLOB_STORE=s3://lab-bucket/oleafly
   OLEAFLY_S3_REGION=eu-west-1
   OLEAFLY_S3_ACCESS_KEY_ID=your-access-key-id
   OLEAFLY_S3_SECRET_ACCESS_KEY=your-secret-access-key
   ```

Amazon S3 के अलावा किसी स्टोर के लिए, `OLEAFLY_S3_ENDPOINT` को उसके पते पर भी सेट करें, जैसे `https://minio.example.org:9000` या `https://<account-id>.r2.cloudflarestorage.com`, और `OLEAFLY_S3_REGION` को उस क्षेत्र पर जो वह मानता है (R2 के लिए `auto`)। सादा `http://` भी चलता है, लेकिन उसे केवल तब इस्तेमाल करें जब स्टोर सर्वर के साथ उसी निजी नेटवर्क पर हो।

बकेट के नाम के बाद का हिस्सा एक वैकल्पिक फ़ोल्डर है। हर फ़ाइल अपने SHA-256 हैश के नाम से रखी जाती है और उस हैश के पहले दो अक्षरों वाले फ़ोल्डर के नीचे बैठती है, इसलिए जिस फ़ाइल का हैश `3f9a` से शुरू होता है वह `oleafly/3f/3f9a...` के रूप में संग्रहीत होती है। स्नैपशॉट का अपना `snapshots` फ़ोल्डर है, जिसमें हर प्रोजेक्ट का एक फ़ोल्डर होता है। जब सर्वर कोई फ़ाइल या स्नैपशॉट वापस पढ़ता है, तो वह बाइट्स को हैश से जाँचता है और बेमेल होने पर उसे ठुकरा देता है। बकेट के बिना यही लेआउट `OLEAFLY_DATA_DIR` के भीतर `blobs` फ़ोल्डर में होता है।

अगर बकेट कोई अनुरोध ठुकरा दे, तो वह अपलोड या डाउनलोड विफल हो जाता है, और सर्वर लॉग दिखाता है कि बकेट ने क्या कहा, जैसे `403 Forbidden (AccessDenied)`। सर्वर की गड़बड़ी, टाइमआउट या टूटा कनेक्शन अलग मामला है: सर्वर कम से कम तीन बार कोशिश करता है, बीच में छोटे यादृच्छिक ठहराव के साथ। अगर वह कोई ऑब्जेक्ट नहीं मिटा पाता, तो नोट कर लेता है और हर मेंटेनेंस दौर में, हर 6 घंटे में, फिर कोशिश करता है, ताकि किसी बाधा के बाद ऑब्जेक्ट छूट न जाएँ।

### स्नैपशॉट और मेमोरी

जब कोई प्रोजेक्ट साझा किया जाता है, तो मालिक का ऐप उसका पहला स्नैपशॉट अपलोड करता है और उस डिवाइस की कुंजी से उस पर हस्ताक्षर करता है। उसके बाद से सर्वर हर स्नैपशॉट खुद बनाता है, पिछले स्नैपशॉट और तब से लोगों द्वारा भेजे गए बदलावों से। पिछले स्नैपशॉट के बाद 1,000 बदलाव जमा होने पर नया स्नैपशॉट बनता है। सर्वर हमेशा कम से कम पिछले 2,000 बदलाव रखता है, ताकि थोड़ी देर के लिए दूर रहा डिवाइस उन्हीं से बाकी काम पकड़ ले और पूरा प्रोजेक्ट दोबारा डाउनलोड न करे।

एक स्नैपशॉट बनाने में पिछले स्नैपशॉट के आकार और उसके बाद के बदलावों के जोड़ का करीब दस गुना लगता है। सर्वर केवल वही बिल्ड शुरू करता है जो `OLEAFLY_SNAPSHOT_MEMORY_MB` में समा जाए, और एक साथ चल रहे बिल्ड वह राशि आपस में बाँटते हैं। अगर कोई बिल्ड न समा जाए, तो सर्वर उसे छोड़ देता है, लॉग में लिखता है कि उसे कितनी मेमोरी चाहिए, और प्रोजेक्ट के सारे बदलाव रखता है। डिवाइस फिर उन बदलावों से थोड़े-थोड़े मेगाबाइट पर बाकी काम पकड़ते हैं। सेटिंग बढ़ाइए और अगला स्नैपशॉट बन जाएगा। सर्वर `OLEAFLY_MAX_PROJECT_MB` से बड़ा स्नैपशॉट संग्रहीत नहीं करता।

### कंपाइल की गई PDF

जब कोई मालिक या संपादक किसी साझा प्रोजेक्ट को सफलतापूर्वक कंपाइल करता है, तो उसका ऐप PDF सर्वर पर भेजता है, और अगर SyncTeX फ़ाइल हो तो वह भी। वह हर प्रोजेक्ट के लिए एक मिनट में ज़्यादा से ज़्यादा एक PDF भेजता है। सर्वर हर प्रोजेक्ट के लिए एक PDF और एक SyncTeX फ़ाइल रखता है, साथ में मुख्य फ़ाइल का नाम, उसे किसने कंपाइल किया और कब। [ब्राउज़र से एक्सेस](/docs/collaboration/server-access/#browser-access) यह PDF प्रोजेक्ट के लोगों को दिखाता है।

हर अपलोड पिछले वाले की जगह ले लेता है, और पुरानी फ़ाइल तब मिटा दी जाती है जब कोई उसका इस्तेमाल न कर रहा हो। कंपाइल की गई फ़ाइलें दूसरी फ़ाइलों के साथ, डिस्क पर या बकेट में, रखी जाती हैं और अपने प्रोजेक्ट के साथ मिटा दी जाती हैं। कंपाइल की गई फ़ाइल `OLEAFLY_MAX_FILE_MB` जितनी बड़ी हो सकती है। वह मालिक के [खाते के स्टोरेज](#limits-per-account) में गिनी जाती है, पर हर घंटे के अपलोड में नहीं।

प्रोजेक्ट का हर सदस्य उसकी कंपाइल की गई फ़ाइलें पढ़ सकता है। केवल मालिक और संपादक ही उन्हें बदल सकते हैं।

## रिवर्स प्रॉक्सी के पीछे

सर्वर सादा HTTP बोलता है, इसलिए उसके आगे कुछ HTTPS संभालता है: Compose सेटअप में Caddy, Coolify का प्रॉक्सी, या कोई वेब सर्वर जो आप पहले से चलाते हैं, जैसे आपकी यूनिवर्सिटी का। आगे जो भी हो, उसे यह करना होगा:

- `OLEAFLY_MAX_PROJECT_MB` जितने बड़े अनुरोध स्वीकार करना
- क्लाइंट का पता `X-Forwarded-For` में जोड़ना

उसे WebSocket अपग्रेड को `/ws` तक पहुँचाना भी चाहिए और उन कनेक्शनों को कम से कम एक घंटे खुला रखना चाहिए। लाइव एडिटिंग जहाँ संभव होती है, उन्हीं का इस्तेमाल करती है। ब्राउज़र से एक्सेस चालू होने पर उसे इन्हें `/web/ws` तक भी पहुँचाना होगा, क्योंकि ब्राउज़र ऐप के पास कोई धीमा वैकल्पिक रास्ता नहीं है।

सर्वर वहाँ चलाएँ जहाँ केवल प्रॉक्सी पहुँच सके। उसी मशीन पर, `OLEAFLY_BIND=127.0.0.1:8080` सेट करें। फिर `OLEAFLY_BEHIND_PROXY=true` सेट करें।

### जब WebSocket कनेक्शन ब्लॉक हों

कुछ नेटवर्क WebSocket कनेक्शन ब्लॉक कर देते हैं, अक्सर फ़िल्टरिंग प्रॉक्सी वाला कोई यूनिवर्सिटी या कंपनी नेटवर्क। वहाँ भी लाइव एडिटिंग काम करती है, थोड़ी धीरे। जब लगातार दो WebSocket कोशिशें विफल हो जाएँ जबकि सर्वर HTTPS पर अब भी जवाब दे रहा हो, तो Oleafly HTTP long-polling पर चला जाता है। वह बदलाव `/api/v1/projects/<project>/frames` पर भेजता है और दूसरे लोगों के बदलावों के लिए `/api/v1/projects/<project>/poll` पर इंतज़ार करता है, हर अनुरोध को `OLEAFLY_POLL_HOLD_SECONDS` तक खुला रखते हुए। हर बदलाव फिर भी पहुँच जाता है। Oleafly हर मिनट दोबारा WebSocket की कोशिश करता है और जैसे ही एक जुड़ जाता है, उसी पर लौट आता है।

Oleafly का **Test connection** और एडमिन कंसोल का **Connection checks** बताते हैं कि ऐसा कब होता है: "Live edits take a slower route because this network blocks the usual one. They still arrive."

अगर आप सर्वर के आगे प्रॉक्सी चलाते हैं, तो फिर भी WebSocket अपग्रेड पहुँचाएँ। Long-polling चलता है, लेकिन बदलावों का हर बैच एक अतिरिक्त अनुरोध और थोड़ी और देर लगाता है।

कुछ प्रॉक्सी उस अनुरोध को बंद कर देते हैं जो 30 सेकंड से कम देर चुप रहे, छोटे `proxy_read_timeout` वाला nginx इनमें से एक है। वे long-polling अनुरोधों को 502 या 504 गड़बड़ी के साथ जवाब देते हैं, और बदलाव देर से पहुँचते हैं। `OLEAFLY_POLL_HOLD_SECONDS` को उस टाइमआउट से कुछ सेकंड कम रखें, जैसे 10 सेकंड के टाइमआउट के लिए `8`।

### OLEAFLY_BEHIND_PROXY क्या बदलता है

सर्वर क्लाइंट का पता दो जगह नोट करता है: सिक्योरिटी लॉग में, और इस बात की [सीमाओं](#limits-for-a-class-on-one-network) में कि एक पता कितनी बार साइन-इन शुरू कर सकता है या लाइव कनेक्शन खोल सकता है।

सेटिंग के बिना सर्वर उसी का पता इस्तेमाल करता है जो उससे जुड़ा। प्रॉक्सी के पीछे वह हमेशा प्रॉक्सी ही होता है, इसलिए सब लोग एक ही सीमा बाँटते हैं और सिक्योरिटी लॉग में केवल प्रॉक्सी का पता दिखता है।

`OLEAFLY_BEHIND_PROXY=true` होने पर सर्वर `X-Forwarded-For` हेडर पढ़ता है और उसका आख़िरी पता इस्तेमाल करता है, जो वही है जो आपके प्रॉक्सी ने जोड़ा। अगर हेडर गायब हो या उसमें कोई मान्य पता न हो, तो सर्वर जुड़ने वाले पते पर लौट जाता है। और कुछ नहीं बदलता। सर्वर `X-Forwarded-Proto`, `X-Forwarded-Host` और `Forwarded` को नज़रअंदाज़ करता है, और जो पते वह बाँटता है उन सबको `OLEAFLY_PUBLIC_URL` से बनाता है।

इसे केवल तब चालू करें जब हर अनुरोध आपके प्रॉक्सी से आता हो। अगर लोग सर्वर तक सीधे भी पहुँच सकते हैं, तो कोई भी मनगढ़ंत `X-Forwarded-For` भेजकर सिक्योरिटी लॉग में कोई भी पता डाल सकता है और साइन-इन सीमा के चारों ओर निकल सकता है।

लगातार दो प्रॉक्सी हों, जैसे Coolify के प्रॉक्सी के आगे Cloudflare, तो `OLEAFLY_PROXY_HOPS=2` सेट करें। सर्वर फिर आख़िर से दूसरा पता लेता है। केवल उन्हीं प्रॉक्सी की गिनती करें जिनसे हर अनुरोध गुज़रता है। सीधे सर्वर तक जाने वाला Cloudflare Tunnel एक माना जाता है।

नंबर जाँचने के लिए, अपने कंप्यूटर से साइन-इन करें और एडमिन कंसोल में **Security log** खोलें। नई प्रविष्टि में आपका सार्वजनिक पता दिखना चाहिए, वही जो `ifconfig.me` जैसी साइट बताती है। अगर उसकी जगह कोई निजी या Cloudflare पता दिखे, तो `OLEAFLY_PROXY_HOPS` एक बढ़ा दें।

### Caddy

Caddy बिना अतिरिक्त सेटिंग के WebSocket कनेक्शन और `X-Forwarded-For` पहुँचाता है, और प्रमाणपत्र खुद ले लेता है। [HTTPS को आगे रखें](/docs/collaboration/server/#put-https-in-front) में पूरा `Caddyfile` है।

### nginx

पहले डोमेन के लिए प्रमाणपत्र लें, जैसे certbot से। फिर इसे `/etc/nginx/conf.d/oleafly.conf` के रूप में सहेजें और `sudo nginx -t && sudo systemctl reload nginx` चलाएँ:

```nginx
map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

server {
    listen 443 ssl;
    server_name collab.example.org;
    ssl_certificate /etc/letsencrypt/live/collab.example.org/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/collab.example.org/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_read_timeout 1h;
        proxy_send_timeout 1h;
        client_max_body_size 200m;
    }
}
```

`client_max_body_size` 200 के डिफ़ॉल्ट `OLEAFLY_MAX_PROJECT_MB` से मेल खाता है। एक को बढ़ाएँ तो दूसरे को भी बढ़ाएँ।

### Apache

आपको Apache 2.4.47 या नया चाहिए, जो Debian 12 और Ubuntu 22.04 और बाद के संस्करणों में है। मॉड्यूल चालू करें:

```sh
sudo a2enmod proxy proxy_http ssl
```

इसे `/etc/apache2/sites-available/oleafly.conf` के रूप में सहेजें, फिर `sudo a2ensite oleafly && sudo systemctl reload apache2` चलाएँ:

```apache
<VirtualHost *:443>
    ServerName collab.example.org
    SSLEngine on
    SSLCertificateFile /etc/letsencrypt/live/collab.example.org/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/collab.example.org/privkey.pem

    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8080/ upgrade=websocket timeout=3600
    ProxyPassReverse / http://127.0.0.1:8080/
</VirtualHost>
```

`upgrade=websocket` WebSocket कनेक्शन पहुँचाता है और `timeout=3600` उन्हें एक घंटे खुला रखता है। Apache खुद क्लाइंट का पता `X-Forwarded-For` में जोड़ देता है।

### किसी पाथ के नीचे

अगर सर्वर किसी पाथ के नीचे है, तो वह पाथ `OLEAFLY_PUBLIC_URL` में शामिल करें, जैसे `https://www.cs.example.edu/oleafly`, और उन कॉलबैक पतों में भी जो आप साइन-इन प्रोवाइडर के पास रजिस्टर करते हैं। सर्वर उस पाथ के साथ और बिना, दोनों तरह जवाब देता है, इसलिए आपका प्रॉक्सी उसे पहुँचा भी सकता है और हटा भी सकता है। nginx के साथ, `location /oleafly/ {` इस्तेमाल करें और भीतर वही लाइनें रखें, और `proxy_pass http://127.0.0.1:8080;` को बिना पाथ रखें ताकि nginx पाथ पहुँचा दे।

## एक नेटवर्क पर क्लास के लिए सीमाएँ

अक्सर पूरी क्लास एक ही नेटवर्क पते से साइन-इन करती है, जैसे किसी यूनिवर्सिटी के NAT से। डिफ़ॉल्ट उसी के लिए सेट हैं:

- **साइन-इन**: एक पते को 300 साइन-इन अनुरोधों का burst मिलता है, फिर प्रति सेकंड दो। एक साइन-इन में करीब छह लगते हैं, इसलिए 50 लोग एक साथ साइन-इन कर सकते हैं। इन्हें `OLEAFLY_SIGN_IN_BURST` और `OLEAFLY_SIGN_IN_PER_MINUTE` से बदलें।
- **ईमेल लिंक**: 15 मिनट में एक पते पर 100, और एक ईमेल पते पर 3। इन्हें `OLEAFLY_EMAIL_LINKS_PER_IP` और `OLEAFLY_EMAIL_LINKS_PER_ADDRESS` से बदलें।
- **साइन-इन कोड**: 10 मिनट में एक पते से 100 कोड, और 10 गलत कोड। इसे `OLEAFLY_DEVICE_CODES_PER_IP` से बदलें।
- **लाइव कनेक्शन** की अपनी, बड़ी सीमा है, ताकि एक पते के पीछे पूरी क्लास रीस्टार्ट के बाद एक साथ दोबारा जुड़ सके। इसे केवल वे कनेक्शन खर्च करते हैं जो अपना सत्र साबित नहीं कर पाते: 300 का burst, फिर प्रति सेकंड दस। जो कनेक्शन अपना सत्र साबित कर लेता है वह अपने ही डिवाइस की गिनती में आता है, जो burst में 60 बार दोबारा जुड़ सकता है, फिर प्रति सेकंड एक बार।

एक `/64` नेटवर्क के सारे IPv6 पते एक ही पता माने जाते हैं। ये सीमाएँ प्रति व्यक्ति तभी काम करती हैं जब सर्वर हर व्यक्ति का असली पता देखता हो, इसलिए अपना [प्रॉक्सी सही सेट करें](#what-oleafly_behind_proxy-changes)।

सर्वर हर लाइव कनेक्शन को हर 30 सेकंड पर पिंग करता है। वह कनेक्शन बंद कर देता है जो उन पिंग के जवाब 90 सेकंड तक न दे, और उसे भी जो सर्वर के भेजे संदेश पढ़ना बंद कर दे।

प्रोजेक्ट सीमाएँ सब पर लागू होती हैं: पूरे प्रोजेक्ट के लिए `OLEAFLY_MAX_PROJECT_MB` (डिफ़ॉल्ट 200 MB), एक फ़ाइल के लिए `OLEAFLY_MAX_FILE_MB` (50 MB) और एक प्रोजेक्ट पर लोगों के लिए `OLEAFLY_MAX_MEMBERS_PER_PROJECT` (20)। एडमिन कंसोल का **Overview** मौजूदा सीमाएँ दिखाता है।

## हर खाते की सीमाएँ

हर खाते पर तीन सीमाएँ लागू होती हैं। जब तक आप इन्हें सेट न करें, ये बंद रहती हैं, सिवाय तब के जब [खुला साइन-अप](/docs/collaboration/server-access/#open-sign-up) चालू हो, जो इन्हें इन डिफ़ॉल्ट के साथ चालू कर देता है:

| सीमा | सेटिंग | खुले साइन-अप के साथ |
| --- | --- | --- |
| खाते के अपने प्रोजेक्टों का स्टोरेज | `OLEAFLY_ACCOUNT_STORAGE_MB` | 100 MB |
| खाते के अपने साझा प्रोजेक्ट | `OLEAFLY_MAX_PROJECTS_PER_ACCOUNT` | 50 |
| खाता एक घंटे में कितने अपलोड करता है | `OLEAFLY_UPLOADS_PER_HOUR` | 300 |

आपका सेट किया मान हमेशा डिफ़ॉल्ट पर भारी पड़ता है। हर मान कम से कम 1 का पूर्णांक होना चाहिए।

- **स्टोरेज** खाते के हर प्रोजेक्ट की फ़ाइलें और बदलावों का इतिहास जोड़ता है, आर्काइव किए गए प्रोजेक्ट भी, और उनकी कंपाइल की गई PDF भी। स्नैपशॉट नहीं गिने जाते। कोई भी व्यक्ति किसी प्रोजेक्ट में जो फ़ाइल जोड़ता है, वह प्रोजेक्ट के मालिक के खाते में गिनी जाती है। मालिक का खाता भर जाने पर सर्वर उसके प्रोजेक्टों के लिए नई फ़ाइलें और कंपाइल की गई PDF अस्वीकार कर देता है, और वह कोई और प्रोजेक्ट साझा नहीं कर सकता। फ़ाइल उसे जोड़ने वाले व्यक्ति के कंप्यूटर पर रहती है। लोगों का टाइप किया पाठ फिर भी सिंक होता है।
- **साझा प्रोजेक्ट** उन प्रोजेक्टों को गिनता है जिन्हें खाता साझा करता है, उनको भी जो अभी अपलोड हो रहे हैं। आर्काइव किए गए प्रोजेक्ट नहीं गिने जाते, इसलिए किसी एक का साझा करना बंद करने से जगह बनती है।
- **अपलोड** एक घंटे की अवधि में हर फ़ाइल और स्नैपशॉट अपलोड गिनता है। कंपाइल की गई PDF नहीं गिनी जातीं। Oleafly अस्वीकार हुई फ़ाइल बाद में अपने आप फिर भेज देता है।

एडमिन कंसोल का **Overview** ये सीमाएँ नहीं दिखाता। खुला साइन-अप चालू होने पर सर्वर का लॉग हर बार शुरू होते समय इनके नाम बताता है।

## लॉग

- **सर्वर लॉग** वही है जो `docker compose logs oleafly-server`, Coolify का **Logs** या `journalctl -u oleafly-server` दिखाते हैं। `OLEAFLY_LOG_LEVEL` तय करता है कि वह कितना कहता है।
- **सिक्योरिटी लॉग** साइन-इन और ठुकराए गए साइन-इन, डिवाइस, लोग, भूमिकाएँ, सेटिंग्स, प्रोजेक्ट और अतिथि दर्ज करता है, हर एक समय और IP पते के साथ। एडमिन और मेंटेनर इसे एडमिन कंसोल में **Security log** के नीचे पढ़ते हैं। `OLEAFLY_SECURITY_LOG_DAYS` दिन से पुरानी प्रविष्टियाँ मिटा दी जाती हैं।
- **प्रोजेक्ट एक्सेस लॉग** दर्ज करते हैं कि किसने प्रोजेक्ट खोला, उससे जुड़ा या उसकी प्रति डाउनलोड की, डिवाइस नाम और समय के साथ। प्रोजेक्ट का मालिक उन्हें तभी चालू करता है, जब **Allow project access logs** चालू हो, और केवल वही मालिक उसे पढ़ सकता है। वही प्रतिधारण लागू होता है।

## बैकअप

पूरे बैकअप में क्या-क्या चाहिए, यह इस पर निर्भर करता है कि फ़ाइलें कहाँ संग्रहीत हैं:

- **डिस्क पर फ़ाइलें** (`OLEAFLY_BLOB_STORE=fs`, डिफ़ॉल्ट): डेटाबेस, फ़ाइलें और स्नैपशॉट सब डेटा फ़ोल्डर में हैं। पूरे फ़ोल्डर का बैकअप लें।
- **बकेट में फ़ाइलें**: डेटा फ़ोल्डर में डेटाबेस रहता है और बकेट में फ़ाइलें और स्नैपशॉट। डेटाबेस की प्रति और बकेट मिलकर पूरा बैकअप है। बकेट पर versioning चालू करें ताकि गलती से मिटाया गया ऑब्जेक्ट वापस लाया जा सके।

नियमित रूप से बैकअप लें और प्रतियाँ निजी रखें, क्योंकि उनमें हर प्रोजेक्ट होता है। आपकी सेटिंग्स, जैसे `.env`, डेटा फ़ोल्डर में नहीं हैं, इसलिए उनकी भी एक प्रति रखें।

Docker के साथ, वॉल्यूम कॉपी करते समय सर्वर कुछ सेकंड के लिए रुकता है। Oleafly खुद दोबारा जुड़ जाता है। यह कमांड सर्वर के फ़ोल्डर में चलाएँ, इंस्टॉलर इस्तेमाल किया हो तो `/opt/oleafly-server`।

```sh
cd /opt/oleafly-server
sudo docker compose stop oleafly-server
sudo docker run --rm -v oleafly-server_oleafly-data:/data:ro -v "$PWD":/backup debian:13.7-slim tar -C /data -czf /backup/oleafly-data-$(date +%F).tar.gz .
sudo docker compose start oleafly-server
```

systemd के साथ:

```sh
sudo systemctl stop oleafly-server
sudo tar -C /var/lib/private/oleafly-server -czf /root/oleafly-data-$(date +%F).tar.gz .
sudo systemctl start oleafly-server
```

आर्काइव को किसी दूसरी मशीन पर कॉपी करें।

Coolify पर, वॉल्यूम का नाम संसाधन की ID से शुरू होता है। उसे `docker volume ls --filter name=oleafly-data` से खोजें, `oleafly-server_oleafly-data` की जगह इस्तेमाल करें, और सर्वर को `docker compose` की जगह Coolify के डैशबोर्ड से रोकें और चलाएँ।

### रीस्टोर अभ्यास

जिस बैकअप को आपने कभी रीस्टोर नहीं किया, वह केवल एक उम्मीद है। यह अभ्यास बैकअप से सर्वर की दूसरी प्रति चलाता है, चल रहे सर्वर को जस का तस छोड़ देता है, और जाँचता है कि दोनों एक ही सर्वर हैं। `2026-10-11` की जगह अपने आर्काइव की तारीख डालें।

```sh
cd /opt/oleafly-server
sudo docker volume create oleafly-restore-drill
sudo docker run --rm -v oleafly-restore-drill:/data -v "$PWD":/backup:ro debian:13.7-slim tar -C /data -xzf /backup/oleafly-data-2026-10-11.tar.gz
sudo docker run -d --name oleafly-restore-drill -v oleafly-restore-drill:/data -e OLEAFLY_PUBLIC_URL=https://restore-drill.invalid -e OLEAFLY_GITHUB_CLIENT_ID=restore-drill -e OLEAFLY_GITHUB_CLIENT_SECRET=restore-drill "$(sudo docker compose images -q oleafly-server)"
sudo docker run --rm --network container:oleafly-restore-drill curlimages/curl:8.22.0 -fsS --retry 10 --retry-connrefused --retry-delay 1 http://127.0.0.1:8080/.well-known/oleafly-server
curl -fsS https://collab.example.org/.well-known/oleafly-server
```

दोनों जवाबों में `server_id` एक जैसा होना चाहिए। अभ्यास वाली प्रति में एक प्लेसहोल्डर GitHub साइन-इन है जो किसी को साइन-इन नहीं करा सकता, और कोई खुला पोर्ट नहीं है, इसलिए कोई उसे इस्तेमाल नहीं कर सकता। काम पूरा होने पर उसे हटा दें:

```sh
sudo docker rm -f oleafly-restore-drill
sudo docker volume rm oleafly-restore-drill
```

### रीस्टोर

Docker Compose के साथ सच में रीस्टोर करने के लिए, सर्वर रोकें, वॉल्यूम की सामग्री को आर्काइव से बदलें, और उसे फिर चालू करें:

```sh
cd /opt/oleafly-server
sudo docker compose stop oleafly-server
sudo docker run --rm -v oleafly-server_oleafly-data:/data -v "$PWD":/backup:ro debian:13.7-slim sh -c 'find /data -mindepth 1 -delete && tar -C /data -xzf /backup/oleafly-data-2026-10-11.tar.gz'
sudo docker compose start oleafly-server
```

systemd के साथ:

```sh
sudo systemctl stop oleafly-server
sudo find /var/lib/private/oleafly-server -mindepth 1 -delete
sudo tar -C /var/lib/private/oleafly-server -xzf /root/oleafly-data-2026-10-11.tar.gz
sudo systemctl start oleafly-server
```

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

### Litestream से लगातार प्रतियाँ

आर्काइव में केवल वही होता है जो उसे बनाते समय था। [Litestream](https://litestream.io) सर्वर के डेटाबेस का हर बदलाव होने के करीब एक सेकंड बाद किसी S3-compatible बकेट में कॉपी कर देता है। Compose फ़ाइल में यह एक वैकल्पिक सेवा के रूप में शामिल है।

Litestream केवल डेटाबेस कॉपी करता है। अगर फ़ाइलें बकेट में हैं, तो बकेट में फ़ाइलें और स्नैपशॉट पहले से हैं, इसलिए Litestream की प्रति और बकेट मिलकर खोई हुई डिस्क वापस ला सकते हैं। अगर फ़ाइलें डिस्क पर हैं, तो वॉल्यूम के आर्काइव बनाते भी रहें, क्योंकि Litestream `blobs` फ़ोल्डर कॉपी नहीं करता।

1. एक बकेट बनाएँ, या किसी बकेट में फ़ोल्डर, जिसे केवल इस सर्वर का Litestream इस्तेमाल करे। इसे `OLEAFLY_BLOB_STORE` के साथ साझा न करें। Litestream को ऐसी कुंजी दें जो बकेट की सूची बना सके और उसमें ऑब्जेक्ट पढ़, लिख और मिटा सके।
2. जानकारी `.env` में जोड़ें:

   ```sh
   LITESTREAM_REPLICA_URL=s3://lab-backups/oleafly-server
   LITESTREAM_REGION=eu-west-1
   LITESTREAM_ACCESS_KEY_ID=your-access-key-id
   LITESTREAM_SECRET_ACCESS_KEY=your-secret-access-key
   COMPOSE_PROFILES=litestream
   ```

   Amazon S3 के अलावा किसी स्टोर के लिए, `LITESTREAM_ENDPOINT` को उसके पते पर भी सेट करें और `LITESTREAM_REGION` को उस क्षेत्र पर जो वह मानता है (R2 के लिए `auto`)। `COMPOSE_PROFILES` हर `docker compose` कमांड में Litestream को शामिल करा देता है।
3. इसे चालू करें:

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

4. जाँचें कि उसने डेटाबेस कॉपी कर दिया। यह `snapshot complete` वाली एक लाइन छापता है:

   ```sh
   sudo docker compose logs litestream | grep 'snapshot complete'
   ```

Litestream दिन में एक बार पूरी प्रति लेता है और हफ़्ते भर की प्रतियाँ और उनके बीच के बदलाव रखता है। समय-सारणी `litestream.yml` में है।

#### Litestream रीस्टोर अभ्यास

यह अभ्यास बकेट से डेटाबेस को एक स्क्रैच वॉल्यूम में रीस्टोर करता है, उस पर सर्वर की दूसरी प्रति चलाता है, और जाँचता है कि दोनों एक ही सर्वर हैं। चल रहे सर्वर को छुआ नहीं जाता।

```sh
cd /opt/oleafly-server
sudo docker run --rm -v oleafly-litestream-drill:/data "$(sudo docker compose images -q oleafly-server)" --version
sudo docker compose run --rm --no-deps -v oleafly-litestream-drill:/restore litestream restore -config /etc/litestream.yml -o /restore/oleafly-server.sqlite3 /data/oleafly-server.sqlite3
sudo docker run -d --name oleafly-litestream-drill -v oleafly-litestream-drill:/data -e OLEAFLY_PUBLIC_URL=https://restore-drill.invalid -e OLEAFLY_GITHUB_CLIENT_ID=restore-drill -e OLEAFLY_GITHUB_CLIENT_SECRET=restore-drill "$(sudo docker compose images -q oleafly-server)"
sudo docker run --rm --network container:oleafly-litestream-drill curlimages/curl:8.22.0 -fsS --retry 10 --retry-connrefused --retry-delay 1 http://127.0.0.1:8080/.well-known/oleafly-server
curl -fsS https://collab.example.org/.well-known/oleafly-server
```

पहला कमांड स्क्रैच वॉल्यूम को सर्वर को चाहिए वाले owner के साथ बनाता है। आख़िरी दोनों जवाबों में `server_id` एक जैसा होना चाहिए। काम पूरा होने पर प्रति हटा दें:

```sh
sudo docker rm -f oleafly-litestream-drill
sudo docker volume rm oleafly-litestream-drill
```

#### Litestream से डेटाबेस रीस्टोर करना

जब डेटाबेस फ़ाइल खराब हो या गायब हो लेकिन डेटा फ़ोल्डर का बाकी हिस्सा ठीक हो, तो सर्वर और Litestream रोकें, डेटाबेस का बचा-खुचा हिस्सा हटाएँ, उसे रीस्टोर करें और फिर चालू करें:

```sh
cd /opt/oleafly-server
sudo docker compose stop oleafly-server litestream
sudo docker run --rm -v oleafly-server_oleafly-data:/data debian:13.7-slim rm -rf /data/oleafly-server.sqlite3 /data/oleafly-server.sqlite3-wal /data/oleafly-server.sqlite3-shm /data/.oleafly-server.sqlite3-litestream
sudo docker compose run --rm --no-deps litestream restore -config /etc/litestream.yml /data/oleafly-server.sqlite3
sudo docker compose up -d
```

बकेट में फ़ाइलों के साथ डिस्क खोने के बाद, ऊपर के कमांड नए, खाली वॉल्यूम पर चलाएँ और `.env` में वही बकेट सेटिंग्स रखें। हर प्रोजेक्ट अपनी फ़ाइलों और स्नैपशॉट के साथ वापस आ जाता है।

डिस्क पर फ़ाइलों के साथ डिस्क खोने के बाद, अपना नवीनतम आर्काइव [रीस्टोर](#restore) करें और वहीं रहने दें। पुराने आर्काइव के ऊपर Litestream का नया डेटाबेस मत रखें। डेटाबेस उन फ़ाइलों और स्नैपशॉट की ओर इशारा करेगा जो आर्काइव में नहीं हैं, और वे प्रोजेक्ट नहीं खुलेंगे।

## अपडेट करना

पहले बैकअप लें। नया रिलीज़ पहली बार चलते ही सर्वर अपना डेटाबेस अपडेट कर लेता है, इसलिए पुराने रिलीज़ पर लौटने का मतलब है अपडेट से पहले लिए गए बैकअप को रीस्टोर करना।

- **एक-कमांड इंस्टॉल**: `curl -fsSL https://oleafly.com/server/install.sh | sudo sh -s -- update` चलाएँ। यह `.env` रखता है, नए रिलीज़ की फ़ाइलें और इमेज लाता है, और सर्वर दोबारा चालू करता है।
- **Docker Compose हाथ से**: नए रिलीज़ की फ़ाइलें [Docker Compose हाथ से](/docs/collaboration/server/#docker-compose-by-hand) की तरह सर्वर के फ़ोल्डर में डाउनलोड करें, फिर `sudo docker compose up -d` चलाएँ।
- **Coolify**: **Redeploy** चुनें। प्रकाशित इमेज के साथ, यह इमेज के टैग के नीचे नवीनतम रिलीज़ खींच लेता है।
- **Render**: सेवा खोलें और एक मैन्युअल डिप्लॉय शुरू करें, जो इमेज दोबारा खींचता है।
- **Railway**: अपने मेन्यू से सेवा दोबारा डिप्लॉय करें। Railway खुद भी GitHub के रजिस्ट्री से इमेज अपडेट कर सकता है।
- **systemd**: नया रिलीज़ [सर्वर डाउनलोड करें](/docs/collaboration/server/#download-the-server) की तरह इंस्टॉल करें, फिर `sudo systemctl restart oleafly-server` चलाएँ।

Oleafly हर जुड़ने पर सर्वर का संस्करण जाँचता है। अगर ऐप और सर्वर साथ काम नहीं कर सकते, तो Oleafly बता देता है कि किसे अपडेट चाहिए।
