#!/bin/bash
set -x #echo on

PYTHON_VERSION=3.11.1

echo "पायथन v$PYTHON_VERSION सेट किया जा रहा है"

echo $PYTHON_VERSION > .python-version
pyenv install $PYTHON_VERSION
pyenv global $PYTHON_VERSION
pyenv local $PYTHON_VERSION
pyenv shell $PYTHON_VERSION

echo "Poetry इंस्टॉलेशन और वर्चुअल एनवायरनमेंट का निर्माण"

pyenv exec pip install poetry
pyenv exec poetry init
pyenv exec poetry install
pyenv exec poetry shell

echo "वर्चुअल एनवायरनमेंट में पायथन निर्भरताओं का इंस्टॉलेशन"

pyenv exec poetry add black --group dev # Dev निर्भरताएँ जोड़ें

echo "वर्चुअल एनवायरनमेंट की विज़ुअल जाँच"

pyenv exec poetry show -v
pyenv exec poetry env info -p

#!/bin/bash
set -x #echo on

pyenv exec poetry run python $@

[tool.poetry]
name = "devops-from-scratch-manual-process"
version = "0.1.0"
description = "स्क्रैच से डेवऑप्स (मैन्युअल सेटअप)"
authors = ["user "]
license = "MIT"
readme = "README.md"
#packages = [{include = "devops_from_scratch_manual_process"}]

[tool.poetry.dependencies]
python = "^3.10.6"
#python = "^3.11"
Django = "^4.2"
django-debug-toolbar = "^4.0"
sortedcontainers = "^2.4.0"
httpx = "^0.23.0"
whitenoise = "^6.2.0"
fontawesomefree = "^6.4.0"
typer = { version = "^0.9.0", extras = ["all"] }
markdown = "^3.4.3"

#[tool.poetry.group.dev.dependencies]
#black = "^23.3.0"
#pytest = "7.3.1"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

import typer

app = typer.Typer()

@app.command()
def hello(name: str):
    print(f"नमस्ते {name}")

@app.command()
def goodbye(name: str, formal: bool = False):
    if formal:
        print(f"अलविदा श्री/सुश्री {name}। आपका दिन शुभ हो।")
    else:
        print(f"बाय {name}!")

from typing import List
from pathlib import Path
from markdown import markdown

def parseMarkdownPosts(path: str) -> List[str]:
    p = Path(path)
    mdFilePaths = list(p.glob('**/*.md'))
    postsHtml = [_parseMarkdown(filePath) for filePath in mdFilePaths]
    return postsHtml

def _parseMarkdown(path: str) -> str:
    data = Path(path).read_text()
    html = markdown(data)
    return html

---
title: मेरी पहली पोस्ट
---

# मेरी पहली पोस्ट

मेरे ब्लॉग में आपका स्वागत है! यह मेरी पहली पोस्ट है।

## कुछ मार्कडाउन विशेषताएँ

- * बोल्ड: **बोल्ड टेक्स्ट**
- * इटैलिक: *इटैलिक टेक्स्ट*
- * स्ट्राइकथ्रू: ~~स्ट्राइकथ्रू टेक्स्ट~~
- * [लिंक](https://example.com)

---
title: मेरी दूसरी पोस्ट
---

# मेरी दूसरी पोस्ट

यह मेरी दूसरी पोस्ट है, जो एक नेस्टेड डायरेक्टरी में स्थित है।

@app.command()
def markdown(mrkdwndir: str):
    import sys
    from pathlib import Path

    current_dir = Path(__file__).parent.resolve()
    sys.path.insert(1, current_dir)

    from services.postsvc import parseMarkdownPosts

    print(f"डायरेक्टरी में मार्कडाउन फ़ाइलों को पुनरावर्ती रूप से पार्स किया जा रहा है: {mrkdwndir}")
    postsHtml = parseMarkdownPosts(mrkdwndir)
    for html in postsHtml:
        print(html)

if __name__ == "__main__":
    app()

#!/bin/bash
set -x #echo on

pyenv exec poetry run django-admin startproject $@

./scripts/local/new-django.sh mytodos

# कुछ नहीं!!!!

"""
mytodos प्रोजेक्ट के लिए ASGI कॉन्फ़िगरेशन।

यह ASGI कॉल करने योग्य को ``application`` नामक मॉड्यूल-स्तरीय वेरिएबल के रूप में उजागर करता है।

इस फ़ाइल के बारे में अधिक जानकारी के लिए, देखें
https://docs.djangoproject.com/en/4.2/howto/deployment/asgi/
"""

import os

from django.core.asgi import get_asgi_application

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mytodos.settings")

application = get_asgi_application()

"""
mytodos प्रोजेक्ट के लिए WSGI कॉन्फ़िगरेशन।

यह WSGI कॉल करने योग्य को ``application`` नामक मॉड्यूल-स्तरीय वेरिएबल के रूप में उजागर करता है।

इस फ़ाइल के बारे में अधिक जानकारी के लिए, देखें
https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/
"""

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mytodos.settings")

application = get_wsgi_application()

"""
mytodos प्रोजेक्ट के लिए जैंगो सेटिंग्स।

जैंगो 4.2 का उपयोग करके 'django-admin startproject' द्वारा उत्पन्न।

इस फ़ाइल के बारे में अधिक जानकारी के लिए, देखें
https://docs.djangoproject.com/en/4.2/topics/settings/

सेटिंग्स और उनके मानों की पूरी सूची के लिए, देखें
https://docs.djangoproject.com/en/4.2/ref/settings/
"""

from pathlib import Path

# प्रोजेक्ट के अंदर पथ बनाएँ जैसे: BASE_DIR / 'subdir'।
BASE_DIR = Path(__file__).resolve().parent.parent


# त्वरित-प्रारंभ विकास सेटिंग्स - उत्पादन के लिए अनुपयुक्त
# देखें https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/

# सुरक्षा चेतावनी: उत्पादन में उपयोग की जाने वाली गुप्त कुंजी को गुप्त रखें!
SECRET_KEY = "django-insecure-r3#=zp=^#5ehd-*ulh0v&x+b3y$lycz=4-=+=_2nn#cipqi8rl"

# सुरक्षा चेतावनी: उत्पादन में डिबग चालू करके न चलाएँ!
DEBUG = True

ALLOWED_HOSTS = []


# एप्लिकेशन परिभाषा

INSTALLED_APPS = [
    "fontawesomefree", # फ्री फोंट्स
    "crud.apps.CrudConfig", # TODOs के लिए CRUD
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
]

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "django.contrib.sessions.middleware.SessionMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.csrf.CsrfViewMiddleware",
    "django.contrib.auth.middleware.AuthenticationMiddleware",
    "django.contrib.messages.middleware.MessageMiddleware",
    "django.middleware.clickjacking.XFrameOptionsMiddleware",
]

ROOT_URLCONF = "mytodos.urls"

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [],
        "APP_DIRS": True,
        "OPTIONS": {
            "context_processors": [
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
            ],
        },
    },
]

WSGI_APPLICATION = "mytodos.wsgi.application"


# डेटाबेस
# https://docs.djangoproject.com/en/4.2/ref/settings/#databases

DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": BASE_DIR / "db.sqlite3",
    }
}


# पासवर्ड सत्यापन
# https://docs.djangoproject.com/en/4.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
    },
]


# अंतर्राष्ट्रीयकरण
# https://docs.djangoproject.com/en/4.2/topics/i18n/

LANGUAGE_CODE = "en-us"

TIME_ZONE = "UTC"

USE_I18N = True

USE_TZ = True


# स्टेटिक फ़ाइलें (CSS, JavaScript, चित्र)
# https://docs.djangoproject.com/en/4.2/howto/static-files/

STATIC_URL = "static/"

# डिफ़ॉल्ट प्राथमिक कुंजी फ़ील्ड प्रकार
# https://docs.djangoproject.com/en/4.2/ref/settings/#default-auto-field

DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"

"""
mytodos प्रोजेक्ट के लिए URL कॉन्फ़िगरेशन।

`urlpatterns` सूची URL को व्यूज़ (views) पर रूट करती है। अधिक जानकारी के लिए कृपया देखें:
    https://docs.djangoproject.com/en/4.2/topics/http/urls/
उदाहरण:
फ़ंक्शन व्यूज़
    1. एक आयात जोड़ें:  from my_app import views
    2. urlpatterns में एक URL जोड़ें:  path('', views.home, name='home')
क्लास-आधारित व्यूज़
    1. एक आयात जोड़ें:  from other_app.views import Home
    2. urlpatterns में एक URL जोड़ें:  path('', Home.as_view(), name='home')
एक अन्य URLconf को शामिल करना
    1. include() फ़ंक्शन आयात करें: from django.urls import include, path
    2. urlpatterns में एक URL जोड़ें:  path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("", include("crud.urls", namespace="crud")),
    path("admin/", admin.site.urls),
]

#!/usr/bin/env python
"""प्रशासनिक कार्यों के लिए जैंगो की कमांड-लाइन उपयोगिता।"""
import os
import sys


def main():
    """प्रशासनिक कार्य चलाएँ।"""
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mytodos.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "जैंगो आयात नहीं किया जा सका। क्या आप सुनिश्चित हैं कि यह इंस्टॉल है और "
            "आपके PYTHONPATH एनवायरनमेंट वेरिएबल पर उपलब्ध है? क्या आप "
            "वर्चुअल एनवायरनमेंट को सक्रिय करना भूल गए?"
        ) from exc
    execute_from_command_line(sys.argv)


if __name__ == "__main__":
    main()

#!/bin/bash
set -x #echo on

pyenv exec poetry run `pwd`/manage.py startapp $@

./scripts/local/new-django-app.sh crud

from django.db import models

# अपने मॉडल यहाँ बनाएँ

class Todo(models.Model):
    name = models.CharField(max_length=100)
    complete = models.BooleanField(default=False)
    #created_at = models.DateTimeField('Created', auto_now_add=True)
    #updated_at = models.DateTimeField('Updated', auto_now=True)

    def __str__(self):
        return self.name

from django.shortcuts import render, get_object_or_404, redirect
from django.views import generic
from django.http import HttpResponseRedirect

# अपने व्यूज़ यहाँ बनाएँ।

from .models import Todo

class IndexView(generic.ListView):
    template_name = 'crud/index.html'
    context_object_name = 'todo_list'

    def get_queryset(self):
        """सभी नवीनतम crud लौटाएँ।"""
        return Todo.objects.order_by('-name')

    #def get_queryset(self):
    #    """सभी नवीनतम crud लौटाएँ।"""
    #    return Todo.objects.order_by('-created_at')

def add(request):
    name = request.POST['name']
    Todo.objects.create(name=name)

    return redirect('crud:index')

def delete(request, todo_id):
    todo = get_object_or_404(Todo, pk=todo_id)
    todo.delete()

    return redirect('crud:index')

def update(request, todo_id):
    todo = get_object_or_404(Todo, pk=todo_id)
    complete = request.POST.get('complete', False)
    if complete == 'on':
        complete = True

    todo.complete = complete

    todo.save()
    return redirect('crud:index')

{% load static %}

<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    
    <title>मेरे TODOstitle>

    
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.4.1/dist/css/bootstrap.min.css" integrity="sha384-HSMxcRTRxnN+Bdg0JdbxYKrThecOKuH5zCYotlSAcp1+c8xmyTe9GYg1l9a69psu" crossorigin="anonymous">

    
    
    

    
    <link href="{% static 'fontawesomefree/css/fontawesome.css' %}" rel="stylesheet" type="text/css">
    <link href="{% static 'fontawesomefree/css/brands.css' %}" rel="stylesheet" type="text/css">
    <link href="{% static 'fontawesomefree/css/solid.css' %}" rel="stylesheet" type="text/css">

    
    <script src="https://unpkg.com/htmx.org@1.9.2">script>
  head>
  <body>
    {% block content %}
    <h1>नमस्ते, दुनिया!h1>
    {% endblock %}

    
    <script src="https://code.jquery.com/jquery-1.12.4.min.js" integrity="sha384-nvAa0+6Qg9clwYCGGPpDQLVpLNn0fRaROjHqs13t4Ggj3Ez50XnGQqc/r8MhnRDZ" crossorigin="anonymous">script>
    
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@3.4.1/dist/js/bootstrap.min.js" integrity="sha384-aJ21OjlMXNL5UyIl/XNwTMqvzeRMZH2w8c5cRVpzpU8Y5bApTppSuUkhZXN0VxHd" crossorigin="anonymous">script>
  body>
html>

{% extends 'crud/base.html' %}

{% block content %}
<div class="container">

  
  <div class="row">
    <div class="offset-md-2 col-lg-9">
      <div class="page-header">
        <h1>
          Todo सूची
        h1>
      div>
    div>
  div>

  
  <div class="row">
    <div class="offset-md-2 col-lg-9">
      <form method="post" action="{% url 'crud:add' %}">
        {% csrf_token %}
        <div class="form-row">
          <div class="col-md-6">
            <input type="text" class="form-control" name="name" placeholder="कपड़े धोना" required>
          div>
          <div class="col-md-6">
            <button type="submit" name="submit" class="btn btn-outline-primary">
              जोड़ें
            button>
          div>
        div>
      form>
    div>
  div>
  <hr />

  
  <div class="row">
    <div class="offset-md-2 col-lg-6">
      <div class="list-group">
        {% for todo in todo_list %}
        <div class="list-group-item {% if todo.complete %} todo-complete {% endif %}">
          <form style="display: inline;" method="post" action="{% url 'crud:update' todo.id %}">
            {% csrf_token %}
            <input type="checkbox" name="complete" onchange="this.form.submit()" {% if todo.complete %} checked
              {% endif %} class="todo-status-checkbox"
              title="{% if not todo.complete %} पूर्ण के रूप में चिह्नित करें {% else %} अपूर्ण के रूप में चिह्नित करें {% endif %}">
          form>
          {{ todo.name }}
          <a href="{% url 'crud:delete' todo.id %}" title="हटाएँ">
            <i class="far fa-trash-alt">i>
          a>
        div>
        {% endfor %}
      div>
    div>
  div>
div>

{% endblock %}

from django.urls import path
from . import views

app_name='todos'
urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
    path('/delete', views.delete, name='delete'),
    path('/update', views.update, name='update'),
    path('add/', views.add, name='add')
]

./scripts/local/pyrun.sh ./manage.py migrate

./scripts/local/pyrun.sh ./manage.py makemigrations crud

./scripts/local/pyrun.sh ./manage.py migrate

chmod 400 mytodos-on-ubuntu-key.pem

#!/bin/bash
set -x #echo on

ssh -i `pwd`/$1.pem $2@$3

#!/bin/bash
set -x #echo on

# मैं कौन हूँ?
whoami

# पायथन की जाँच करें
which python3 # python3 उबंटू के हालिया संस्करणों पर पहले से इंस्टॉल आता है
which pip3 # जाँचें कि क्या python3-pip इंस्टॉल है
which poetry # जाँचें कि क्या python3-poetry इंस्टॉल है

# उबंटू पैकेज रजिस्ट्री सूचियों को अपडेट करें
sudo apt update

# Poetry इंस्टॉल करें
sudo apt install python3-pip python3-poetry

#!/bin/bash
set -x #echo on

scp -i `pwd`/$1.pem -r $2 $3@$4:$5 # -r फ़ाइलों को पुनरावर्ती रूप से कॉपी करने के लिए है

[inet_http_server]
port = 0.0.0.0:9001
username = user
password = 1234

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface

[supervisord]
serverurl=http://0.0.0.0:9001

[program:mytodos]
directory = /home/ubuntu/mytodos_app
command = sudo poetry run python manage.py runserver 0.0.0.0:80
autostart = true
autorestart = true
#stderr_logfile = /var/log/mytodos/app.err.log
#stdout_logfile = /var/log/mytodos/app.out.log

import http from 'k6/http';
import { sleep, check } from 'k6';
import { htmlReport } from 'https://raw.githubusercontent.com/benc-uk/k6-reporter/main/dist/bundle.js';
import { textSummary } from 'https://jslib.k6.io/k6-summary/0.0.1/index.js';
export let options = {
  // vus: 100,
  // duration: '30s',
  // iterations: 10,
  // minIterationDuration: '10s',
  stages: [
    { duration: '25s', target: 32 }, // 4 PODS
    { duration: '1m', target: 80 }, // 4 PODS
    // { duration: '300s', target: 800 },
    // { duration: '600s', target: 1200 },
    // { duration: '14m40s', target: 4000 },
    // { duration: '4m40s', target: 1600 },
    // { duration: '8m40s', target: 8000 },
    // { duration: '14m40s', target: 18000 }, Perf Box dies that High
    { duration: '15s', target: 0 },
  ],
  // batch: 8000,
  // batch: 4000,
  batch: 100,
  // batch: 1200,
  // batchPerHost: 18000000,
  batchPerHost: 1440000,
  // batchPerHost: 640000000,
  noConnectionReuse: false,
  // noConnectionReuse: true,
  discardResponseBodies: true,
};

let requestHeaders = {
  'User-Agent': 'k6',
  'Accept': 'application/json',
  // 'Content-Type': 'application/json',
  // 'Authorization': 'Bearer {{ .Jwt }}',
  'X-Consumer-Username': 'k6-Benchmarker',
};

export default function () {
  const res = http.get(
      'http://3.96.193.218',
      {headers: requestHeaders}
  );
  // sleep(1);
  const checkRes = check(res, {
    'status is 200': (r) => r.status === 200,
    // 'response body': (r) => r.body.indexOf('Feel free to browse') !== -1,
  });
}

export function handleSummary(data) {
  return {
    './perf-report.html': htmlReport(data),
    stdout: textSummary(data, { indent: ' ', enableColors: true }),
  };
}

हम एक सरल TODO एप्लिकेशन बनाने के लिए जैंगो वेब फ्रेमवर्क का उपयोग करेंगे। जैंगो एक उच्च-स्तरीय पायथन वेब फ्रेमवर्क है जो तेजी से विकास और स्वच्छ, व्यावहारिक डिज़ाइन को सक्षम बनाता है। आप आधिकारिक वेबसाइट पर जाकर जैंगो के बारे में अधिक जान सकते हैं: https://www.djangoproject.com/

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

अपने वेब एप्लिकेशन को बनाने और परीक्षण करने के लिए, हम पायथन पोएट्री और पायटेस्ट का उपयोग करेंगे। पोएट्री पायथन के लिए एक निर्भरता प्रबंधन उपकरण है जो पैकेज प्रबंधन प्रक्रिया को सुव्यवस्थित करता है। पायटेस्ट एक लोकप्रिय परीक्षण फ्रेमवर्क है जो यूनिट परीक्षणों को लिखना और चलाना आसान बनाता है। आप आधिकारिक वेबसाइट पर जाकर पायथन पोएट्री के बारे में अधिक जान सकते हैं: https://python-poetry.org/ और पायटेस्ट के बारे में यहाँ अधिक जान सकते हैं: https://pytest.org/

हम एप्लिकेशन को बनाने और परीक्षण करने की प्रक्रिया से गुजरेंगे, परीक्षण के महत्व और यह डेवऑप्स वर्कफ़्लो में कैसे फिट बैठता है, इस पर जोर देंगे।

हम अपनी वर्चुअल मशीन का प्रावधान करने के लिए AWS Lightsail और Bash का उपयोग करेंगे। AWS Lightsail एक सरलीकृत क्लाउड प्लेटफ़ॉर्म है जो वर्चुअल प्राइवेट सर्वर, स्टोरेज और नेटवर्किंग को लॉन्च और प्रबंधित करना आसान बनाता है। Bash एक यूनिक्स शेल और कमांड भाषा है जो डेवऑप्स वर्कफ़्लो में व्यापक रूप से उपयोग की जाती है। आप AWS Lightsail के बारे में यहाँ अधिक जान सकते हैं: https://aws.amazon.com/lightsail/ और Bash के बारे में यहाँ: https://www.gnu.org/software/bash/

हमारे वक्ता एप्लिकेशन को होस्ट करने के लिए एक वर्चुअल मशीन के प्रावधान की प्रक्रिया पर चर्चा करेंगे, उपलब्ध विभिन्न विकल्पों की व्याख्या करेंगे और आपकी आवश्यकताओं के लिए सबसे अच्छा विकल्प कैसे चुनें, यह बताएंगे।

हमारे डेटाबेस प्रावधान के लिए, हम AWS Lightsail PostgreSQL या विकल्प के रूप में CockroachDB का उपयोग करेंगे। PostgreSQL एक शक्तिशाली, ओपन-सोर्स रिलेशनल डेटाबेस प्रबंधन प्रणाली है जो वेब एप्लिकेशन विकास में व्यापक रूप से उपयोग की जाती है। CockroachDB एक वितरित SQL डेटाबेस है जिसे स्केलेबिलिटी और लचीलेपन के लिए डिज़ाइन किया गया है। आप AWS Lightsail PostgreSQL के बारे में यहाँ अधिक जान सकते हैं: https://aws.amazon.com/lightsail/features/databases/ और CockroachDB के बारे में यहाँ: https://www.cockroachlabs.com/

हम एप्लिकेशन के लिए डेटाबेस के प्रावधान की प्रक्रिया पर चर्चा करेंगे, और उपलब्ध विभिन्न विकल्पों का पता लगाएंगे।

अपने एप्लिकेशन को वर्चुअल मशीन पर तैनात करने के लिए, हम SSH और SCP का उपयोग करेंगे। SSH (सिक्योर शेल) एक सुरक्षित नेटवर्क प्रोटोकॉल है जो दो प्रणालियों के बीच एन्क्रिप्टेड संचार की अनुमति देता है। SCP (सिक्योर कॉपी) दो प्रणालियों के बीच फ़ाइलों को सुरक्षित रूप से स्थानांतरित करने के लिए एक कमांड-लाइन उपकरण है। आप SSH के बारे में यहाँ अधिक जान सकते हैं: https://www.ssh.com/ssh/ और SCP के बारे में यहाँ: https://linuxize.com/post/how-to-use-scp-command-to-securely-transfer-files/

हमारे वक्ता हमें एप्लिकेशन को वर्चुअल मशीन पर तैनात करने की प्रक्रिया के माध्यम से ले जाएंगे, और परिनियोजन में स्वचालन के महत्व की व्याख्या करेंगे।

अपने एप्लिकेशन की विश्वसनीयता और स्केलेबिलिटी सुनिश्चित करने के लिए, हम अपने लोड बैलेंसर के रूप में NGINX का उपयोग करेंगे। NGINX एक लोकप्रिय ओपन-सोर्स वेब सर्वर और रिवर्स प्रॉक्सी है जो अपने उच्च प्रदर्शन और स्केलेबिलिटी के लिए जाना जाता है। आप NGINX के बारे में यहाँ अधिक जान सकते हैं: https://www.nginx.com/

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

हम अपने एप्लिकेशन के लिए एक कस्टम डोमेन सेट करने के लिए AWS Lightsail का उपयोग करेंगे। एक कस्टम डोमेन आपके वेब एप्लिकेशन के लिए अधिक पेशेवर और ब्रांडेड URL प्रदान करता है, और उपयोगकर्ता अनुभव में सुधार कर सकता है। आप AWS Lightsail के साथ कस्टम डोमेन सेट करने के बारे में यहाँ अधिक जान सकते हैं: https://aws.amazon.com/lightsail/features/dns/

हमारे वक्ता हमें एप्लिकेशन के लिए एक कस्टम डोमेन सेट करने की प्रक्रिया के माध्यम से ले जाएंगे, ब्रांडिंग और उपयोगकर्ता अनुभव के महत्व की व्याख्या करेंगे।

हम अपने एप्लिकेशन की क्रैश लचीलापन सुनिश्चित करने के लिए Supervisord का उपयोग करेंगे। Supervisord एक क्लाइंट/सर्वर सिस्टम है जो यूनिक्स-जैसे ऑपरेटिंग सिस्टम पर प्रक्रियाओं के नियंत्रण और निगरानी की अनुमति देता है। आप Supervisord के बारे में यहाँ अधिक जान सकते हैं: http://supervisord.org/

हम वेब एप्लिकेशन के लिए क्रैश लचीलेपन के महत्व पर चर्चा करेंगे, और डेवऑप्स प्रथाओं का उपयोग करके इसे लागू करने का तरीका खोजेंगे।

अपनी लॉगिंग और निगरानी आवश्यकताओं के लिए, हम जैंगो लॉगिंग और Supervisord UI का उपयोग करेंगे। जैंगो लॉगिंग जैंगो वेब फ्रेमवर्क के लिए एक अंतर्निहित लॉगिंग सिस्टम है जो आपके एप्लिकेशन में घटनाओं को लॉग करने का एक लचीला और कॉन्फ़िगर करने योग्य तरीका प्रदान करता है। Supervisord UI Supervisord द्वारा नियंत्रित प्रक्रियाओं के प्रबंधन और निगरानी के लिए एक वेब-आधारित इंटरफ़ेस है। आप जैंगो लॉगिंग के बारे में यहाँ अधिक जान सकते हैं: https://docs.djangoproject.com/en/3.2/topics/logging/ और Supervisord UI के बारे में यहाँ: https://github.com/Supervisor/supervisor/blob/master/docs/webui.rst

हमारे वक्ता वेब एप्लिकेशन के लिए लॉगिंग और निगरानी के महत्व पर चर्चा करेंगे, और एप्लिकेशन के लिए लॉगिंग और निगरानी सेट करने की प्रक्रिया से गुजरेंगे।

हम नई आवश्यकताओं के आधार पर अपने एप्लिकेशन को अपडेट करने के लिए SCP और जैंगो माइग्रेशन का उपयोग करेंगे। SCP (सिक्योर कॉपी) दो प्रणालियों के बीच फ़ाइलों को सुरक्षित रूप से स्थानांतरित करने के लिए एक कमांड-लाइन उपकरण है, और जैंगो माइग्रेशन आपके एप्लिकेशन के विकसित होने पर आपके डेटाबेस स्कीमा को अपडेट करने का एक तरीका प्रदान करते हैं। आप जैंगो माइग्रेशन के बारे में यहाँ अधिक जान सकते हैं: https://docs.djangoproject.com/en/3.2/topics/migrations/ और SCP के बारे में यहाँ: https://linuxize.com/post/how-to-use-scp-command-to-securely-transfer-files/

हम नई आवश्यकताओं के आधार पर एप्लिकेशन को अपडेट करने की प्रक्रिया पर चर्चा करेंगे, और समझाएंगे कि डेवऑप्स प्रथाएं इस प्रक्रिया को कैसे आसान और अधिक कुशल बना सकती हैं।

उत्पादन में हमारे डेटाबेस माइग्रेशन के लिए, हम उपयोग की गई सेटिंग्स के आधार पर sqlite3 और PostgreSQL ड्राइवरों के साथ जैंगो DB माइग्रेशन का उपयोग करेंगे। यह हमें डेटा खोए बिना डेटाबेस स्कीमा परिवर्तन करने की अनुमति देगा। आप जैंगो DB माइग्रेशन के बारे में यहाँ अधिक जान सकते हैं: https://docs.djangoproject.com/en/3.2/topics/migrations/

हमारे वक्ता उत्पादन में डेटाबेस को माइग्रेट करने की प्रक्रिया पर चर्चा करेंगे, और डेवऑप्स प्रथाओं का उपयोग करके डेटाबेस माइग्रेशन को लागू करने का तरीका खोजेंगे।

अपने एप्लिकेशन की सुरक्षा सुनिश्चित करने के लिए, हम सुरक्षा परीक्षण और फज़िंग के लिए PythonFuzz का उपयोग करेंगे। PythonFuzz फज़ परीक्षण के लिए एक पायथन-आधारित उपकरण है जिसे आपके कोड में बग और कमजोरियों को खोजने के लिए डिज़ाइन किया गया है। आप PythonFuzz के बारे में यहाँ अधिक जान सकते हैं: https://github.com/python-security/pyfuzz

हमारे वक्ता वेब एप्लिकेशन के लिए सुरक्षा परीक्षण और फज़िंग के महत्व पर चर्चा करेंगे, और डेवऑप्स प्रथाओं का उपयोग करके सुरक्षा परीक्षण और फज़िंग को लागू करने की प्रक्रिया से गुजरेंगे।

अपने एप्लिकेशन की विश्वसनीयता और उपलब्धता सुनिश्चित करने के लिए, हम बैकअप और पुनर्स्थापना प्रक्रियाएं सेट करने के लिए जैंगो डेटाबेस बैकअप का उपयोग करेंगे। जैंगो डेटाबेस बैकअप एक जैंगो एक्सटेंशन है जो आपके डेटाबेस को बैकअप और पुनर्स्थापित करने का एक सरल तरीका प्रदान करता है। आप जैंगो डेटाबेस बैकअप के बारे में यहाँ अधिक जान सकते हैं: https://django-dbbackup.readthedocs.io/en/stable/

हम वेब एप्लिकेशन के लिए बैकअप और पुनर्स्थापना प्रक्रियाओं के महत्व पर चर्चा करेंगे, और डेवऑप्स प्रथाओं का उपयोग करके बैकअप और पुनर्स्थापना प्रक्रियाओं को सेट करने और परीक्षण करने की प्रक्रिया से गुजरेंगे।