# जीटहब कार्यों के साथ आधुनिक प्रकाशन रणनीति

<!--category-- DevOps, CI/CD, GitHub Actions -->
<datetime class="hidden">2025-12-04T12:00</datetime>

**बुनियादी सिद्धांत** यह एकgile विकास के लिए महत्वपूर्ण है।

यह गाइड मैं उत्पादन में प्रयोग करता हूँ जारी करने की रणनीतियों को शामिल करता है। [GitHub क्रियाएँ](https://docs.github.com/en/actions) इस रिपोजिटरी में कार्यप्रवाह

[TOC]

## एक नज़र में जारी करने की रणनीति

विस्तृत विवरण में डुबोने से पहले

रणनीति | सबसे अच्छा | जटिलता के लिए
|----------|----------|------------|-----------|
| **टैग-आधारित** अनुप्रयोग
| **शाखा** निरंतर तैनाती | कम | | | स्टार्टअप |, | तेजी से
| **जीटफ्लो** | विनियमित जारीियां, बहुविध संस्करणों || | उच्च | | | उद्यम | МSK4 | अनुपालन
| **ट्रंक-आधारित + विशेषता झण्डा** उच्च-velocity टीमें |Medium|Big tech,mature startups|
| **मोनोरेपो बहु-- पैकेज** | पुस्तकालयों, साझा कोडबेस || | मध्यम | | | प्लेटफार्म टीमें |

### कहाँ क्या काम करता है

**स्टार्टअप & लघु टीम**: टैग के साथ आरंभ करें।

**उद्यम**अनुपालन के लिए प्रायः GitFlow या इसी प्रकार की आवश्यकता होती है।

**एकल विकासकर्ता**: टैग-आधारित आदर्श है।

**प्लेटफॉर्म/लाइब्रेरी टीम**प्रति पैकेज में स्वतंत्र संस्करणिंग के साथ एकल रेपो रणनीति की आवश्यकता है

## टैग-आधारित तैनाती

सरलतम और सबसे विश्वसनीय रणनीति

### पर्यावरण लक्ष्य

```yaml
on:
  push:
    tags:
      - 'release-*'  # Production
      - 'local-*'    # Dev environment
```

```yaml
- name: Build Docker image
  run: |
    TAG_NAME=${GITHUB_REF#refs/tags/}
    if [[ "$TAG_NAME" == local-* ]]; then
      docker build -t myapp:local .
    else
      docker build -t myapp:latest -t myapp:$(date +%s) .
    fi
```

**यह क्यों काम करता है**सरल मानसिक मॉडल

```bash
# Deploy to production
git tag release-v2024.12.01 && git push origin release-v2024.12.01

# Deploy to dev
git tag local-feature-test && git push origin local-feature-test
```

### बहु-- पैकेज संस्करण

कई प्रकाशन योग्य पैकेजों के साथ मोनोरीपोज़ के लिए

```yaml
# Different workflows, different tag patterns
# umami-net.yml
on:
  push:
    tags: ['umamiv*.*.*']  # e.g., umamiv1.0.5

# fetchextension.yml
on:
  push:
    tags: ['fetchextension-v*.*.*']  # e.g., fetchextension-v1.2.0
```

संस्करण को निकालें और इसे पूरे में उपयोग करें:

```yaml
- name: Extract version
  run: echo "VERSION=${GITHUB_REF#refs/tags/umamiv}" >> $GITHUB_OUTPUT

- name: Build & Pack
  run: |
    dotnet build -c Release -p:Version=${{ steps.version.outputs.VERSION }}
    dotnet pack -c Release -p:PackageVersion=${{ steps.version.outputs.VERSION }}
```

स्वचालित संस्करणिंग के लिए [मिनर](https://github.com/adamralph/minver) जीट टैग से संस्करण गणना करता है

```xml
<PackageReference Include="MinVer" Version="6.0.0" PrivateAssets="all" />
<PropertyGroup>
  <MinVerTagPrefix>umamiv</MinVerTagPrefix>
</PropertyGroup>
```

## शाखा-आधारित तैनाती

जब कोड विशिष्ट शाखाओं पर उतरता है तो स्वचालित रूप से लागू करें

```yaml
on:
  push:
    branches: [main]      # → Production
    # branches: [develop] # → Staging
```

**प्रॉस**: कोई म्यानुअल चरण नहीं
**त्रुटि**: अनियमित विनियोजन संभव है, कम स्पष्ट इतिहास

मैं एक हाइब्रिड दृष्टिकोण का उपयोग करता हूँ - शाखा धकेलने पर बनाता है | ( | आईसी सत्यापन |), | लेकिन सिर्फ टैगों पर प्रकाशित करें |

```yaml
on:
  push:
    tags: ['scheduler-*']
    branches: [main, local]

jobs:
  build:
    # Always build
  publish:
    if: startsWith(github.ref, 'refs/tags/')  # Only publish on tags
```

## Watchtower के साथ स्वचालित अद्यतन

स्वचालित विनियोजनों के लिए [वॉचटोवर](https://containrrr.dev/watchtower/) स्वचालित रूप से नई छवियाँ निकालता है

```yaml
services:
  app:
    image: myapp:latest
    labels:
      - "com.centurylinklabs.watchtower.enable=true"

  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 300  # Check every 5 minutes
```

**विनियोजन प्रवाह**: पुश टैग | → | GitHub कार्य निर्माण करता है |→ | रजिस्ट्री में पुश करता है

## गुणवत्ता द्वार

सभी कार्यप्रवाह में गेट शामिल होना चाहिए

```yaml
- name: Run tests
  run: dotnet test --configuration Release

- name: Build
  run: dotnet build --configuration Release

# Tests or build fail → workflow stops → no publish
```

बहुआयामी के लिए-फ्रेमवर्क पैकेजों के लिए

```yaml
- run: dotnet build -c Release --framework net8.0
- run: dotnet build -c Release --framework net9.0
```

## ओआईडीसी के साथ पासवर्डहीन प्रकाशन

आधुनिक दृष्टिकोण - घुमाने के लिए कोई रहस्य नहीं

```yaml
permissions:
  id-token: write
  contents: read

- uses: NuGet/login@v1
  with:
    user: 'myusername'

- run: dotnet nuget push *.nupkg --api-key ${{ steps.login.outputs.NUGET_API_KEY }}
```

GitHub अपने OIDC टोकन को एक छोटा '-' जीवित NuGet API कुंजी के लिए बांटता है

## आपूर्ति श्रृंखला सुरक्षा

[पुरातत्व प्रमाणन](https://docs.github.com/en/actions/security-for-github-actions/using-artifact-attestations) प्रमाणित करें कि आपके वास्तु CI में निर्मित हैं

```yaml
permissions:
  id-token: write
  attestations: write

- uses: docker/build-push-action@v6
  id: push
  with:
    push: true
    tags: myapp:latest

- uses: actions/attest-build-provenance@v2
  with:
    subject-name: index.docker.io/myuser/myapp
    subject-digest: ${{ steps.push.outputs.digest }}
    push-to-registry: true
```

उपभोक्ता द्वारा सत्यापित करें `gh attestation verify oci://index.docker.io/myuser/myapp:latest --owner myuser`

यह प्राप्त करता है [SLSA स्तर 2](https://slsa.dev/spec/v1.0/levels)स्तर के लिए . उपयोग [पुनः उपयोग योग्य कार्यप्रवाह](https://docs.github.com/en/actions/sharing-automations/reusing-workflows).

## पूर्वावलोकन वातावरण

समूहों को विलयन से पहले परिवर्तनों की पूर्वावलोकन करने के लिए भागीदारों की आवश्यकता है

**उद्यम दृष्टिकोण** शाखा

```yaml
on:
  pull_request:
    types: [opened, synchronize]

- run: |
    BRANCH=$(echo ${{ github.head_ref }} | sed 's/[^a-zA-Z0-9]/-/g')
    docker build -t myapp:preview-$BRANCH .
    # Deploy to k8s namespace, cloud platform, etc.
```

**स्टार्टअप** - अपने स्थानीय मशीन का सुरंगन करें

```bash
# Cloudflare Tunnel (free)
cloudflared tunnel run --url http://localhost:5000 my-preview
# → https://my-preview.cfargotunnel.com
```

या उपयोग करें [ताररक्षक](https://www.wireguard.com/) अपने dev मशीन में आंतरिक टीम पहुँच के लिए VPN.

## व्यावहारिक सुझाव

**टैग साफ करें**गिट टैग हमेशा के लिए चिपका रहता है

```bash
git tag -d old-test-tag                      # Delete local
git push origin :refs/tags/old-test-tag      # Delete remote
```

**नामकरण सम्मेलन**: संगत होना

- `release-YYYY.MM.DD` उत्पादन के लिए
- `local-feature-name` डेव के लिए
- `packagev1.2.3` पुस्तकालयों के लिए

**ठ̧ें**: Store in [GitHub SecretsComment](https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions)कोड में कभी नहीं

- `DOCKER_HUB_ACCESS_TOKEN`
- `NUGET_API_KEY` ( या OIDC का उपयोग करें
- `NPM_TOKEN`

**मोनोरेपो विकास**विकास के दौरान परियोजना संदर्भ का उपयोग करें

```xml
<ProjectReference Include="..\MyLib\MyLib.csproj" />
<!-- <PackageReference Include="MyLib" Version="1.0.0" /> -->
```

## Kubernetes में जा रहा है

समान सिद्धांत

डोकर कम्पोज़ करें
|----------------|------------|
वॉचटोवर [आरगोसीडी](https://argo-cd.readthedocs.io/) / [फ्लक्स](https://fluxcd.io/docs/) |
डॉकर
| कंटेनर पुनः आरंभ करने के लिए
मैनुअल रोलरबैक

## सारांश

1. **सरल प्रारंभ करें**: टैग-आधारित तैनाती अधिकांश आवश्यकताओं को पूरा करती है
2. **आवश्यकता पड़ने पर जटिलता जोड़ें**: शाखा
3. **स्वचालित गुणवत्ता द्वार**: प्रकाशन से पहले परीक्षाएं पास होनी चाहिए
4. **रोलबैक सक्षम करें**: Timestamped टैग या GitOps इतिहास
5. **अपने पाइपलाइन को सुरक्षित करें**: गोपनीयता के लिए OIDC
6. **अपने संदर्भ को मिलाएँ**Solo dev

यहाँ दिखाया गया कार्यप्रवाह इस रिपोजिटरी में चलता है - जाँच `.github/workflows/` पूर्ण कार्यान्वयन के लिए

**याद रखें**: त्वरित