भाग 1 : Python और PyPI के लिए एक साधारण CI/CD पाइपलाइन सेट अप करें

प्रकाशित: 17 July 2025

उद्देश्य: पायथन एप्लिकेशन के लिए एक मिनिमलिस्ट लेकिन कार्यात्मक CI/CD पाइपलाइन सेटअप करने में पाठक का मार्गदर्शन करना, PyPI पर स्वचालित तैनाती सहित।

परिचय

विकास प्रक्रियाओं का स्वचालन आधुनिक परियोजनाओं में अनिवार्य बन गया है। एक अच्छी तरह से डिज़ाइन किया गया CI/CD पाइपलाइन केवल विकास चक्र के प्रारंभ में रिग्रेशन का पता लगाने में मदद करता ही नहीं, बल्कि पूरी तरह से तैनाती प्रक्रिया को भी स्वचालित कर देता है।

इस लेख में, हम एक पायथन एप्लिकेशन के लिए GitHub Actions के साथ एक पूर्ण पाइपलाइन सेट अप करने का तरीका देखेंगे, निरंतर एकीकरण (CI) से लेकर PyPI पर निरंतर तैनाती (CD) तक।

पाइपलाइन की वास्तुकला

हमारी पाइपलाइन दो अलग वर्कफ़्लो से मिलकर बनी है :

  1. CI पाइपलाइनहर push और pull request पर निष्पादित किया जाता है

  2. CD पाइपलाइन: केवल GitHub रिलीज़ के दौरान ट्रिगर होता है

@startuml
!theme plain

package "GitHub भंडार" {
  [Source Code] as source
  [GitHub Actions] as actions
}

package "सतत इंटीग्रेशन पाइपलाइन" {
  [Checkout] as checkout_ci
  [Setup Python] as python_ci
  [Install Dependencies] as deps_ci
  [Linting (Ruff)] as lint
  [Unit Tests] as tests
}

package "सतत वितरण पाइपलाइन" {
  [Checkout] as checkout_cd
  [Setup Python] as python_cd
  [Build Package] as build
  [Publish to PyPI] as pypi
}

source --> actions : Push/PR
actions --> checkout_ci
checkout_ci --> python_ci
python_ci --> deps_ci
deps_ci --> lint
lint --> tests

source --> actions : रिलीज़
actions --> checkout_cd : रिलीज़ पर
checkout_cd --> python_cd
python_cd --> build
build --> pypi

@enduml

सतत एकीकरण (CI) पाइपलाइन की सेटअप

CI वर्कफ़्लो संरचना

CI वर्कफ़्लो को कोड में प्रत्येक योगदान को मान्य करने के लिए डिज़ाइन किया गया है। यहाँ उसकी पूरी कॉन्फ़िगरेशन है :

name: CI/CD Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.x'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
        pip install ruff pytest pytest-mock

    - name: Run Linting (Ruff)
      run: ruff check .

    - name: Run Tests (Pytest)
      run: pytest

CI के चरणों का विश्लेषण

1. ट्रिगर (on)

----
----
on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
----

पाइपलाइन ट्रिगर होती है: - प्रत्येक पुश शाखा पर`main` - प्रत्येक pull request की ओर`main`

यह सुनिश्चित करता है कि मुख्य कोड स्थिर रहता है और किसी भी योगदान को एकीकरण से पहले सत्यापित किया जाता है।

==== 2. निष्पादन पर्यावरण

----

runs-on: ubuntu-latest

Ubuntu Latest पायथन के अधिकांश प्रोजेक्ट्स के लिए प्रदर्शन, लागत और संगतता के बीच एक अच्छा संतुलन प्रदान करता है।

==== 3. कोड चेकआउट

```yaml
----
----
- name: Checkout code
  uses: actions/checkout@v4
----

क्रिया`checkout@v4`रिपॉज़िटरी का स्रोत कोड प्राप्त करता है। वर्ज़न v4 प्रदर्शन और सुरक्षा में सुधार लाता है।

==== 4. पायथन कॉन्फ़िगरेशन

----

- name: Set up Python uses: actions/setup-python@v5 with: python-version: '3.x'

का उपयोग`'3.x'`यह स्वचालित रूप से पायथन 3 के अंतिम स्थिर संस्करण का उपयोग करने की अनुमति देता है, जिससे रखरखाव सरल हो जाता है।

==== 5. निर्भरताओं की स्थापना

```yaml
----
----
- name: Install dependencies
  run: |
    python -m pip install --upgrade pip
    pip install -r requirements.txt
    pip install ruff pytest pytest-mock
----

यह चरण: - pip को नवीनतम संस्करण में अपडेट किया गया परियोजना की निर्भरताएँ स्थापित करें - विकास उपकरण जोड़ें (लिंटिंग और परीक्षण)

==== 6. रफ़ के साथ लिंटिंग

----

- name: Run Linting (Ruff) run: ruff check .

**रफ़**यह एक अत्यंत तेज़ पाइथन लिंटर है जो रस्ट में लिखा गया है। यह कई टूल्स (Flake8, Black, isort) की कार्यक्षमताओं को एक ही कुशल टूल में मिलाता है।

==== 7. टेस्टों का निष्पादन

```yaml
----
----
- name: Run Tests (Pytest)
  run: pytest
----

पायटेस्ट पूरी परीक्षण सूट निष्पादित करता है, जिससे यह सुनिश्चित होता है कि परिवर्तन रिग्रेशन नहीं लाते।

== डिप्लॉयमेंट पाइपलाइन कॉन्फ़िगरेशन (सीडी)

=== वर्कफ़्लो CD की संरचना

सीडी वर्कफ़्लो केवल गिटहब रिलीज़ के दौरान ट्रिगर होता है और PyPI पर प्रकाशन को स्वचालित करता है:

[source,yaml]
----
name: Publish to PyPI

on:
  release:
    types:
      - published

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Python
      uses: actions/setup-python@v5
      with:
        python-version: '3.x'

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install setuptools wheel twine

    - name: Build and publish
      env:
        TWINE_USERNAME: __token__
        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
      run: |
        python setup.py sdist bdist_wheel
        twine upload dist/*
----

=== सीडी के चरणों का विश्लेषण

==== ट्रिगर रिलीज़

----

on: release: types: - published

CD पाइपलाइन केवल तभी ट्रिगर होती है जब एक GitHub रिलीज़ प्रकाशित की जाती है। यह दृष्टिकोण तैनातियों पर सटीक नियंत्रण सुनिश्चित करता है।

==== 2. बिल्ड टूल्स की स्थापना

```yaml
----
----
pip install setuptools wheel twine
----

- **setuptools**: पायथन पैकेजिंग टूल्स - **पहिया**आधुनिक पायथन वितरण प्रारूप - **सुतली**PyPI पर अपलोड करने के लिए सुरक्षित उपकरण

==== 3. प्रमाणीकरण की कॉन्फ़िगरेशन

----

env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}

प्रमाणीकरण पाइपी एपीआई टोकन का उपयोग करता है जिसे गिटहब सीक्रेट के रूप में संग्रहीत किया गया है, जो सामान्य प्रमाणपत्रों से अधिक सुरक्षित है।

==== निर्माण और प्रकाशन

```yaml
----
----
run: |
  python setup.py sdist bdist_wheel
  twine upload dist/*
----

- `sdist`एक स्रोत वितरण बनाएँ - `bdist_wheel`wheel बनाएँ (बाइनरी वितरण) - `twine upload`PyPI पर वितरण प्रकाशित करें

== पायथन पैकेज की कॉन्फ़िगरेशन

=== setup.py की संरचना

पाइपलाइन चलाने के लिए, आपके प्रोजेक्ट में एक फ़ाइल शामिल होनी चाहिए।`setup.py`:

[source,python]
----
from setuptools import setup, find_packages

with open("README.adoc", "r", encoding="utf-8") as fh:
    long_description = fh.read()

setup(
    name="playlist-downloader",
    version="1.0.0",
    author="Votre Nom",
    author_email="[email protected]",
    description="CLI tool for managing YouTube playlists",
    long_description=long_description,
    long_description_content_type="text/plain",
    url="https://github.com/cheroliv/playlist-downloader",
    packages=find_packages(),
    classifiers=[
        "Development Status :: 4 - Beta",
        "Intended Audience :: Developers",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.8",
        "Programming Language :: Python :: 3.9",
        "Programming Language :: Python :: 3.10",
        "Programming Language :: Python :: 3.11",
    ],
    python_requires=">=3.8",
    install_requires=[
        "typer>=0.9.0",
        "yt-dlp>=2023.1.6",
        "google-api-python-client>=2.70.0",
        "google-auth-oauthlib>=0.7.1",
        "pymonad>=2.4.0",
        "pyyaml>=6.0",
    ],
    entry_points={
        "console_scripts": [
            "playlist-downloader=cli:app",
        ],
    },
)
----

=== setup.py के मुख्य बिंदु

1. **मेटाडेटा**नाम, संस्करण, लेखक, विवरण
2. **निर्भरताएँ**आवश्यक पैकेजों की सूची
3. **प्रवेश बिंदु**प्रदर्शित CLI कमांडें
4. **वर्गीकर्ता**PyPI के लिए मेटाडेटा

== GitHub Secrets के साथ सुरक्षा

=== PyPI टोकन कॉन्फ़िगरेशन

1. **PyPI पर एक एपीआई टोकन बनाएँ**:

- PyPI में लॉग इन करें Account Settings में जाएँ > API टोकन - उपयुक्त अनुमतियों वाले एक नया टोकन बनाएँ

1. **GitHub में सीक्रेट जोड़ें**:

- रिपॉजिटरी सेटिंग्स > सीक्रेट्स और वेरिएबल > एक्शन - एक नया रहस्य नामित बनाइए`PYPI_API_TOKEN` अपना PyPI टोकन चिपकाएँ

[plantuml, secrets-flow, svg]
----
@startuml
!theme plain

actor Developer as dev
participant "GitHub भंडार" as repo
participant "GitHub क्रियाएँ" as actions
participant PyPI

dev -> repo : कन्फ़िगर करें PYPI_API_TOKEN रहस्य
repo -> actions : रिलीज़ पर CD पाइपलाइन ट्रिगर करें
actions -> actions : सुरक्षित रूप से गुप्त जानकारी तक पहुँच बनाएँ
actions -> PyPI : टोकन के साथ प्रमाणित करें
PyPI -> PyPI : पैकेज को सत्यापित और प्रकाशित करें

note over actions, PyPI
टोकन लॉग्स में कभी उजागर नहीं होता
स्वचालित रोटेशन संभव है
end note

@enduml
----

== पूर्ण तैनाती कार्यप्रवाह

=== डिप्लॉयमेंट अनुक्रम

[plantuml, deployment-sequence, svg]
----
@startuml
!theme plain

actor Developer as dev
participant "स्थानीय Git" as git
participant "GitHub" as github
participant "GitHub क्रियाएँ" as actions
participant PyPI
participant "अंतिम उपयोगकर्ता" as users

dev -> git : git tag v1.0.0
dev -> git : git push origin v1.0.0
git -> github : पुश टैग
dev -> github : टैग से रिलीज़ बनाएँ
github -> actions : सीडी पाइपलाइन ट्रिगर करें
actions -> actions : कोड चेकआउट करें
actions -> actions : Python पर्यावरण सेटअप करें
actions -> actions : बिल्ड टूल्स इंस्टॉल करें
actions -> actions : वितरण बनाएँ (sdist + wheel)
actions -> PyPI : PyPI पर टोकन के साथ अपलोड करें
PyPI -> PyPI : सत्यापित और प्रकाशित
users -> PyPI : pip इंस्टॉल करें playlist‑downloader

note over dev, github
रिलीज़ निर्माण को स्वचालित किया जा सकता है या इसे GitHub UI के माध्यम से मैन्युअल रूप से किया जा सकता है।
end note

@enduml
----

=== पाइपलाइन की स्थितियाँ

[plantuml, pipeline-states, svg]
----
@startuml
!theme plain

[*] --> Idle

Idle --> CI_Running : Push/PR created
CI_Running --> CI_Success : सभी जाँच पास हैं
CI_Running --> CI_Failed : लिंटिंग/Tests असफल
CI_Success --> Idle : विलय पूरा हो गया
CI_Failed --> Idle : सुधारें और पुनः प्रयास करें

Idle --> CD_Running : प्रकाशित रिलीज़
CD_Running --> CD_Success : पैकेज प्रकाशित
CD_Running --> CD_Failed : निर्माण/Upload त्रुटि
CD_Success --> Idle : PyPI पर पैकेज उपलब्ध है
CD_Failed --> Idle : सुधारें और फिर से रिलीज़ का प्रयास करें

note on link #red : ब्लॉक्स मिलाएँ
note on link #green : डिप्लॉयमेंट की अनुमति देता है

@enduml
----

== अच्छी प्रथाएँ और अनुकूलन

=== 1. संस्करण प्रबंधन

समानात्मक Git टैग्स का उपयोग करें :

----

git tag -a v1.2.3 -m "Release version 1.2.3" git push origin v1.2.3

=== मैट्रिक्स परीक्षण

कई पायथन संस्करणों पर परीक्षण करने के लिए :

```yaml
----
----
strategy:
  matrix:
    python-version: [3.8, 3.9, "3.10", "3.11"]
----

=== निर्भरताओं का कैश

कैश के साथ बिल्ड को तेज़ करें :

----

- name: Cache pip dependencies uses: actions/cache@v3 with: path: ~/.cache/pip key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt') }}

=== डिप्लॉयमेंट वातावरण

GitHub पर्यावरणों का उपयोग नियंत्रित तैनाती के लिए करें :

```yaml
----
----
jobs:
  deploy:
    environment: production
    runs-on: ubuntu-latest
----

== उपयोग केस और वास्तुकला

=== यूज़ केस डायग्राम

[plantuml, use-cases, svg]
----
@startuml
!theme plain

left to right direction

actor "डेवलपर" as dev
actor "GitHub क्रिया" as ga
actor "अंतिम उपयोगकर्ता" as user

package "CI/CD सिस्टम" {
  usecase "लिंटिंग चलाएँ" as lint
  usecase "परीक्षण निष्पादित करें" as test
  usecase "पैकेज बनाएँ" as build
  usecase "प्रकाशित करें PyPI" as publish
  usecase "रिलीज़ बनाएँ" as release
}

dev --> lint : वह कोड पुश करता है
dev --> test : कोड पुश करता है
dev --> release : रिलीज़ बनाएँ
ga --> build : जारी करने पर ट्रिगर
ga --> publish : सफल बिल्ड के बाद
user --> publish : Paquet de téléchargements

lint .> test : triggers
test .> build : on success
build .> publish : on success

@enduml
----

=== डिप्लॉयमेंट आर्किटेक्चर

[plantuml, deployment-architecture, svg]
----
@startuml
!theme plain

cloud "GitHub" {
  [Source Repository]
  [GitHub Actions]
  [Secrets Store]
}

cloud "PyPI" {
  [Package Registry]
  [Distribution Files]
}

node "CI/CD पाइपलाइन" {
  [Linting]
  [Testing]
  [Building]
  [Publishing]
}

[Source Repository] --> [GitHub Actions] : Triggers
[GitHub Actions] --> [Linting]
[Linting] --> [Testing]
[Testing] --> [Building]
[Building] --> [Publishing]
[Publishing] --> [Package Registry] : Uploads
[Secrets Store] --> [Publishing] : Provides token

note as N1
सुरक्षित टोकन-आधारित प्रमाणीकरण
end note

[Secrets Store] .. N1

@enduml
----

== निगरानी और डिबगिंग

=== लॉग्स और मॉनिटरिंग

GitHub Actions प्रत्येक चरण के लिए विस्तृत लॉग प्रदान करता है। डिबग करने के लिए :

1. **लॉग्स को जाँचें**हर कदम का
2. **डिबग सक्षम करें**साथ`ACTIONS_STEP_DEBUG`
3. **artefacts का उपयोग करें**बिल्ड फ़ाइलों को सहेजने के लिए

----

- name: Upload build artifacts uses: actions/upload-artifact@v3 if: failure() with: name: build-logs path: build/

=== सूचनाएँ

स्लैक या ईमेल सूचनाएँ जोड़ें :

```yaml
----
----
- name: Notify on failure
  if: failure()
  uses: 8398a7/action-slack@v3
  with:
    status: ${{ job.status }}
    webhook_url: ${{ secrets.SLACK_WEBHOOK }}
----

== निष्कर्ष

एक मजबूत CI/CD पाइपलाइन को गिटहब एक्शंस के साथ लागू करने से विकास अनुभव में कट्टरपंथी बदलाव आ जाता है। लिंटिंग, परीक्षण और तैनाती को स्वचालित करके, आप :

- **त्रुटियाँ कम करें**उत्पादन में - **चक्रों को तेज़ करें**विकास - **विश्वास बढ़ाएँ**आपके रिलीज़ में - **सहयोग को आसान बनाएँ**टीम में

यह पाइपलाइन लिंटिंग टूल्स, टेस्ट फ्रेमवर्क्स, या तैनाती के गंतव्य को समायोजित करके विभिन्न प्रकार के Python प्रोजेक्ट्स के लिए अनुकूलित किया जा सकता है।

इन वर्कफ़्लो को कॉन्फ़िगर करने में किया गया प्रारम्भिक निवेश तैनाती के दौरान मैन्युअल त्रुटियों में कमी और समय की बचत से जल्दी ही लाभदायक हो जाता है।

== पूरक संसाधन

- https://docs.github.com/en/actions[गिटहब एक्शंस दस्तावेज़] - https://packaging.python.org/[पायथन पैकेजिंग गाइड] - https://docs.pytest.org/[दस्तावेज़ीकरण Pytest] - https://docs.astral.sh/ruff/[दस्तावेज़ Ruff] - https://twine.readthedocs.io/[दस्तावेज़ ट्वाइन]

फ़ंक्शनल पाइपलाइन पहुँच गया! अब आपके पास एक सरल CI/CD पाइपलाइन है जो आपको अपने परीक्षणों को स्वचालित करने और GitHub Actions से सीधे PyPI पर अपना Python पैकेज प्रकाशित करने की अनुमति देती है।

हालांकि, यह पाइपलाइन जानबूझकर न्यूनतम रूप में बनी हुई है। यह अभी तक कुछ आवश्यक पहलुओं को नहीं कवर करती जो एक पेशेवर संदर्भ में आवश्यक हैं:

पायथन के मल्टी-वर्ज़न परीक्षण,

स्वचालित सुरक्षा विश्लेषण,

Test PyPI के माध्यम से चरणबद्ध तैनाती

पाइपलाइन की निगरानी और मेट्रिक्स,

वर्जनिंग का स्वचालन और आधुनिक सर्वोत्तम प्रथाओं के एकीकरण (pyproject.toml)

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

संबंधित लेख

HyperFrames-Gradle : AsciiDoc को MP4 वीडियो में बदलें
31 May 2026
मेरी LLM उपभोग का ऑडिट: SQLite, OpenCode, Ollama Cloud, और क्यों मेरा प्रो सब्सक्रिप्शन वैश्विक बाजार को बर्बाद कर रहा है
18 May 2026
स्वतंत्र प्लग‑इन + उपभोक्ता मूल आर्किटेक्चर: मेरे Gradle बिल्ड्स क्यों दोहराते हैं
14 May 2026
सिफ़ारिश इंजन के रूप में Knowledge Graph: मैंने क्रमानुक्रमिक « सम्बन्धित लेख » को कैसे समाप्त कर दिया
12 May 2026