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

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

पाइपलाइन ट्रिगर होती है : - हर push शाखा पर`main` - हर पुल अनुरोध की ओर`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'`यह Python 3 के नवीनतम स्थिर संस्करण का स्वचालित रूप से उपयोग करने की सुविधा प्रदान करता है, जिससे रखरखाव सरल हो जाता है।

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

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

यह चरण : - Met à jour pip vers la dernière version - परियोजना की निर्भरताएँ स्थापित करें विकास उपकरण जोड़ें (लिंटिंग और परीक्षण)

==== 6. Ruff के साथ लिंटिंग

----

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

**Ruff**यह एक अत्यंत तेज़ Python लिंटर है, जो रस्ट में लिखा गया है। यह कई टूल (Flake8, Black, isort) की विशेषताओं को एक ही उच्च प्रदर्शन वाले टूल में जोड़ता है।

==== 7. परीक्षण का निष्पादन

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

Pytest पूरे टेस्ट सुइट को चलाता है, जिससे यह सुनिश्चित होता है कि संशोधन कोई रिग्रेशन नहीं लाते।

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

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

CD वर्कफ़्लो केवल GitHub रिलीज़ पर ट्रिगर होता है और 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/*
----

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

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

----

on: release: types: - published

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

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

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

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

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

----

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

प्रमाणीकरण PyPI API टोकन का उपयोग करता है, जो GitHub पर एक राज के रूप में संग्रहीत किया जाता है, और यह सामान्य पहचान प्रमाणपत्रों की तुलना में अधिक सुरक्षित है।

==== 4. बिल्ड और प्रकाशन

```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. **प्रवेश बिंदु**### ग्रेडल एकीकरण
JBake को JBake Gradle प्लगिन का उपयोग करके या JBake CLI को सीधे बुलाकर Gradle बिल्ड में एकीकृत किया जा सकता है:

----

tasks.register<JavaExec>("bake") { mainClass.set("org.jbake.launcher.Main") classpath = configurations["jbake"] args = listOf(projectDir.absolutePath, "$buildDir/jbake") } ```

: CLI कमांड्स उजागर

1. **वर्गीकरणकर्ता**PyPI के लिए मेटाडेटा

== गिटहब सीक्रेट्स के साथ सुरक्षा

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

1. **PyPI पर API टोकन बनाएं**:

- PyPI पर लॉग इन करें - जाएँ Account Settings > API tokens - Créez un nouveau token avec les permissions appropriées

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

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

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

actor Developer as dev
participant "गिटहब रिपॉजिटरी" as repo
participant "GitHub Actions" as actions
participant PyPI

dev -> repo : Configure PYPI_API_TOKEN secret
repo -> actions : Trigger CD pipeline on release
actions -> actions : Access secret securely
actions -> PyPI : Authenticate with token
PyPI -> PyPI : Validate and publish package

note over actions, PyPI
  Token never exposed in logs
  Automatic rotation possible
end note

@enduml
----

== पूर्ण तैनाती वर्कफ़्लो

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

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

actor Developer as dev
participant "Local Git" as git
participant "GitHub" as github
participant "GitHub Actions" as actions
participant PyPI
participant "End Users" as users

dev -> git : git tag v1.0.0
dev -> git : git push origin v1.0.0
git -> github : Push tag
dev -> github : Create release from tag
github -> actions : Trigger CD pipeline
actions -> actions : Checkout code
actions -> actions : Setup Python environment
actions -> actions : Install build tools
actions -> actions : Build distributions (sdist + wheel)
actions -> PyPI : Upload to PyPI with token
PyPI -> PyPI : Validate and publish
users -> PyPI : pip install playlist-downloader

note over dev, github
  Release creation can be automated
  or done manually through GitHub UI
end note

@enduml
----

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

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

[*] --> Idle

Idle --> CI_Running : Push/PR created
CI_Running --> CI_Success : All checks pass
CI_Running --> CI_Failed : Linting/Tests fail
CI_Success --> Idle : Merge completed
CI_Failed --> Idle : Fix and retry

Idle --> CD_Running : Release published
CD_Running --> CD_Success : Package published
CD_Running --> CD_Failed : Build/Upload error
CD_Success --> Idle : Package available on PyPI
CD_Failed --> Idle : Fix and retry release

note on link #red : Blocks merge
note on link #green : Allows deployment

@enduml
----

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

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

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

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

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

बहुत से Python संस्करणों पर परीक्षण करने के लिए:

----

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

=== 3. Cache des Dépendances

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

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

=== 4. परिनियोजन पर्यावरण

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

----

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

== उपयोग केस और आर्किटेक्चर

=== केस उपयोग आरेख

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

left to right direction

actor "डेवलपर" as dev
actor "GitHub Actions" as ga
actor "End User" as user

package "CI/CD प्रणाली" {
  usecase "लिंटिंग चलाएँ" as lint
  usecase "टेस्ट निष्पादित करें" as test
  usecase "### gradle का एकीकरण
JBake को JBake Gradle प्लगिन का उपयोग करके या JBake CLI को सीधे बुलाकर Gradle बिल्ड में एकीकृत किया जा सकता है:

```kotlin
tasks.register<JavaExec>("bake") {
    mainClass.set("org.jbake.launcher.Main")
    classpath = configurations["jbake"]
    args = listOf(projectDir.absolutePath, "$buildDir/jbake")
}" as build
  usecase "PyPI पर प्रकाशित करें" as publish
  usecase "Create Release" as release
}

dev --> lint : Pushes code
dev --> test : Pushes code
dev --> release : Creates release
ga --> build : On release trigger
ga --> publish : After successful build
user --> publish : Downloads package

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
  Secure token-based
  authentication
end note

[Secrets Store] .. N1

@enduml
----

== मॉनिटरिंग और डिबगिंग

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

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

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

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

=== सूचनाएँ

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

----

- 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[GitHub Actions दस्तावेज़] - https://packaging.python.org/[Python पैकेजिंग गाइड] - https://docs.pytest.org/[Pytest दस्तावेज़] - https://docs.astral.sh/ruff/[दस्तावेज़ Ruff] - https://twine.readthedocs.io/[दस्तावेज़ीकरण Twine]

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

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

Python के कई संस्करणों के परीक्षण,

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

टेस्ट PyPI के माध्यम से धीरे-धीरे तैनाती,

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

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

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