[tool.poetry]
name = "devops-from-scratch-automated-basics"
version = "0.1.0"
description = "DevOps from Scratch (Automated Basics)"
authors = ["user "]
license = "MIT"
readme = "README.md"
#packages = [{include = "devops_from_scratch_automated_basics"}]

[tool.poetry.dependencies]
#python = "^3.10.6"
python = "^3.11"
sortedcontainers = "^2.4.0"
httpx = "^0.23.0"
invoke = "2.0.0"
fabric = "^3.0.1"
paramiko = "^3.1.0"
typer = { version = "^0.9.0", extras = ["all"] }

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

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

[ubuntu.main]
host = ubuntu@15.222.44.100
app_dir = /home/ubuntu
pem_file = ubuntu-main.pem

import configparser

from fabric import (
  Connection, Config, task,
)


# कॉन्फ़िगरेशन फ़ाइल पढ़ें
config = configparser.ConfigParser()
config.read('config.ini')

def get_server_connection(server, config=config):

    # उन होस्ट को परिभाषित करें जहाँ कार्य निष्पादित किए जाएंगे
    host = config.get(server, 'host')

    # .pem फ़ाइल का पथ सेट करें
    pem_file = config.get(server, 'pem_file')

    # कनेक्शन के लिए कॉन्फ़िगरेशन बनाएँ
    fab_config = Config(
        overrides={
            'connect_kwargs': {
                'key_filename': pem_file
            }
    })

    # कनेक्शन बनाएँ
    conn = Connection(host, config=fab_config)

    return conn


# उबंटू मुख्य कॉन्फ़िगरेशन अनुभाग का नाम
#server = 'ubuntu.main'

# एप्लिकेशन की निर्देशिका को परिभाषित करें
#app_dir = config.get(server, 'app_dir')

@task
def machine_info(ctx, server):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:
        conn.run('uname')
        conn.run('uname -n')
        conn.run('uname -v')
        conn.run('uname -m')
        conn.run('lsb_release -a')
        conn.run('whoami')
        conn.run('date')

# अपने मौजूदा पैकेज की सूची अपडेट करें
sudo apt update

# कुछ आवश्यक पैकेज इंस्टॉल करें जो `apt` को HTTPS पर पैकेज का उपयोग करने देते हैं
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# आधिकारिक Docker रिपॉजिटरी के लिए GPG कुंजी को अपने सिस्टम में जोड़ें
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# APT स्रोतों में Docker रिपॉजिटरी जोड़ें
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# यह सुनिश्चित करने के लिए कि अतिरिक्त को पहचाना गया है, अपने मौजूदा पैकेज की सूची को फिर से अपडेट करें
sudo apt update

# सुनिश्चित करें कि आप डिफ़ॉल्ट उबंटू रिपॉजिटरी के बजाय Docker रिपॉजिटरी से इंस्टॉल करने वाले हैं
apt-cache policy docker-ce

# Docker इंस्टॉल करें
sudo apt install docker-ce

# जांचें कि क्या यह चल रहा है
sudo systemctl status docker

#+name fabfile.py

@task
def install_docker(ctx, server):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:

        # अपने मौजूदा पैकेज की सूची अपडेट करें
        conn.sudo('apt update')

        # कुछ आवश्यक पैकेज इंस्टॉल करें जो `apt` को HTTPS पर पैकेज का उपयोग करने देते हैं
        #with settings(prompts={'Do you want to continue [Y/n]?':'Y'}):
        conn.sudo('apt install apt-transport-https ca-certificates curl software-properties-common')

        # आधिकारिक Docker रिपॉजिटरी के लिए GPG कुंजी को अपने सिस्टम में जोड़ें
        conn.run('curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg')

        # APT स्रोतों में Docker रिपॉजिटरी जोड़ें
        conn.run('echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null')

        # यह सुनिश्चित करने के लिए कि अतिरिक्त को पहचाना गया है, अपने मौजूदा पैकेज की सूची को फिर से अपडेट करें
        conn.sudo('apt update')

        # सुनिश्चित करें कि आप डिफ़ॉल्ट उबंटू रिपॉजिटरी के बजाय Docker रिपॉजिटरी से इंस्टॉल करने वाले हैं
        conn.run('apt-cache policy docker-ce')

        # Docker इंस्टॉल करें
        conn.sudo('apt install docker-ce')

        # जांचें कि क्या यह चल रहा है
        conn.sudo('systemctl status docker')

ध्यान दें कि `install_docker` फ़ंक्शन इडेम्पोटेंट नहीं है और निष्पादन के दौरान कुछ चरणों में विफल हो सकता है।

`sudo` के बिना Docker

# अपने उपयोगकर्ता नाम को docker समूह में जोड़ें
sudo usermod -aG docker ${USER}

नई समूह सदस्यता लागू करें, सर्वर से लॉग आउट करें और वापस लॉग इन करें (वैकल्पिक?)

su - ${USER}

groups

#+name fabfile.py

@task
def configure_docker(ctx, server):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:

        # अपने उपयोगकर्ता नाम को docker समूह में जोड़ें
        conn.sudo('usermod -aG docker ${USER}')
        #conn.run('su - ${USER}')
        conn.run('groups')

जांचें कि क्या Docker Hub की इमेज सुलभ हैं और उन्हें डाउनलोड किया जा सकता है

docker run hello-world

#+name fabfile.py

@task
def check_docker(ctx, server):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:

        conn.run('docker run hello-world')

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

Un conteneur est un package logiciel léger, autonome et exécutable qui comprend tout ce qui est nécessaire pour exécuter un logiciel, y compris le code, un environnement d'exécution, des bibliothèques, des variables d'environnement et des fichiers de configuration. Les conteneurs sont conçus pour fournir un environnement cohérent et reproductible, qui peut être facilement porté sur différents systèmes hôtes. Ils isolent le processus d'application de l'hôte, offrant une couche supplémentaire de sécurité, et permettent un contrôle des ressources, offrant une efficacité.

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

Les conteneurs sont utilisés parce qu'ils offrent plusieurs avantages. Premièrement, ils garantissent que les applications fonctionnent de la même manière, quel que soit le lieu et le moment où elles sont exécutées, ce qui augmente la vitesse et la fiabilité du déploiement. Deuxièmement, ils fournissent une isolation des processus en gardant les applications et leurs dépendances séparées les unes des autres, améliorant ainsi la sécurité. Troisièmement, ils utilisent efficacement les ressources du système, ce qui réduit les coûts d'infrastructure.

• LXC (LinuX Containers) एक ऑपरेटिंग सिस्टम-स्तरीय वर्चुअलाइजेशन विधि है जो एक ही कंट्रोल होस्ट पर कई अलग-थलग लिनक्स सिस्टम (कंटेनर) चलाने की अनुमति देती है। LXC सॉफ़्टवेयर एप्लिकेशन और उनके वातावरण को अंतर्निहित सिस्टम से अलग करने के लिए लिनक्स कर्नेल cgroups और नेमस्पेस कार्यक्षमता का उपयोग करता है। LXC को पहली बार 2008 में जारी किया गया था और यह लिनक्स कंटेनर मैनेजर का पहला और सबसे पूर्ण कार्यान्वयन था। इसे VM से "हल्का" माना जाता है क्योंकि यह हार्डवेयर स्तर पर नहीं, बल्कि OS स्तर पर चलता है।
• Docker एक ओपन-सोर्स प्लेटफ़ॉर्म है जिसका उपयोग एप्लिकेशन को कंटेनरों में पैक करके उनके परिनियोजन, स्केलिंग और प्रबंधन को स्वचालित करने के लिए किया जाता है। 2013 में पेश किया गया Docker, डेवलपर्स और सिस्टम एडमिन के लिए ऑपरेटिंग वातावरण से स्वतंत्र एप्लिकेशन विकसित करने, पैक करने और चलाने के लिए एक मानकीकृत इंटरफ़ेस प्रदान करने के लिए LXC के दृष्टिकोण पर विस्तारित हुआ। Docker ने तब से LXC को प्रमुख कंटेनरीकरण तकनीक के रूप में प्रतिस्थापित कर दिया है।

• LXC (LinuX Containers) est une méthode de virtualisation au niveau du système d'exploitation qui permet d'exécuter plusieurs systèmes Linux isolés (conteneurs) sur un seul hôte de contrôle. LXC utilise les fonctionnalités cgroups et namespace du noyau Linux pour isoler les applications logicielles et leur environnement du système sous-jacent. LXC a été lancé pour la première fois en 2008 et a été la première implémentation la plus complète du gestionnaire de conteneurs Linux. Il est considéré comme "plus léger" qu'une VM car il fonctionne au niveau du système d'exploitation, et non au niveau du matériel.
• Docker est une plateforme open source utilisée pour automatiser le déploiement, la mise à l'échelle et la gestion des applications en les emballant dans des conteneurs. Docker, introduit en 2013, a développé l'approche de LXC en fournissant une interface standardisée pour les développeurs et les administrateurs système afin de développer, empaqueter et exécuter des applications indépendamment de l'environnement d'exploitation. Docker a depuis remplacé LXC comme la principale technologie de conteneurisation.

यह आरेख Docker में कुछ बुनियादी अवधारणाओं को कवर करता है:

graph TB

DockerEngine(Docker Engine)

DockerEngine -- Runs --> DockerContainer
DockerEngine -- Builds --> DockerImage

DockerFile(Dockerfile: Recipe for Images) -- Defines --> DockerImage

DockerHub(Docker Hub: Public Repository) -- Stores and Shares --> DockerImage

DockerContainer(Docker Container: Tiny, stand-alone, executable package)
DockerImage(Docker Image: Blueprints for Containers) -- Creates --> DockerContainer

subgraph "Analogy: Construction"
  DockerFile -- "Architect's Plan" --> DockerImage
  DockerImage -- "Pre-fab house parts" --> DockerContainer
end

1. Docker Engine: रनटाइम जो कंटेनर बनाता और चलाता है। यह एक निर्माण कंपनी की तरह है जो घर बनाती और उनका रखरखाव करती है।
2. Dockerfile: एक टेक्स्ट दस्तावेज़ जिसमें वे सभी कमांड होते हैं जिन्हें एक उपयोगकर्ता इमेज को असेंबल करने के लिए कमांड लाइन पर कॉल कर सकता है। यह घर के लिए एक आर्किटेक्ट की योजना की तरह है।
3. Docker Image: Docker का ब्लूप्रिंट जो कंटेनर के एक विशिष्ट उदाहरण का प्रतिनिधित्व करता है। यह घर के पहले से निर्मित हिस्सों की तरह है, जो निर्माण के लिए तैयार हैं।
4. Docker Container: एक निष्पादन योग्य पैकेज जिसमें एप्लिकेशन चलाने के लिए आवश्यक सब कुछ शामिल है। यह निर्मित घर की तरह है, जो पहले से निर्मित हिस्सों (इमेज) पर आधारित है।
5. Docker Hub: एक क्लाउड-आधारित रजिस्ट्री सेवा जो आपको कोड रिपॉजिटरी से लिंक करने, अपनी इमेज बनाने और उनका परीक्षण करने की अनुमति देती है। यह विभिन्न पहले से निर्मित घर के हिस्सों के सार्वजनिक प्रदर्शन या भंडारण की तरह है, जिसका उपयोग किसी भी निर्माण कंपनी (Docker Engine) द्वारा किया जा सकता है।

graph TB

DockerEngine(Moteur Docker)

DockerEngine -- Exécute --> DockerContainer
DockerEngine -- Construit --> DockerImage

DockerFile(Fichier Docker: Recette pour les Images) -- Définit --> DockerImage

DockerHub(Hub Docker: Dépôt Public) -- Stocke et Partage --> DockerImage

DockerContainer(Conteneur Docker: Petit paquet exécutable autonome)
DockerImage(Image Docker: Plans pour les Conteneurs) -- Crée --> DockerContainer

subgraph "Analogie: Construction"
  DockerFile -- "Plan d'architecte" --> DockerImage
  DockerImage -- "Pièces préfabriquées de maison" --> DockerContainer
end

Ce diagramme couvre quelques concepts de base de Docker :

1. Docker Engine (Moteur Docker): L'environnement d'exécution qui construit et exécute des conteneurs. C'est comme une entreprise de construction qui construit et entretient des maisons.
2. Dockerfile (Fichier Docker): Un document texte qui contient toutes les commandes qu'un utilisateur pourrait appeler sur la ligne de commande pour assembler une image. C'est comme le plan d'un architecte pour une maison.
3. Docker Image (Image Docker): Le plan de Docker qui représente une instance spécifique d'un conteneur. C'est comme les pièces préfabriquées d'une maison, prêtes à être construites.
4. Docker Container (Conteneur Docker): Un paquet exécutable qui comprend tout ce qui est nécessaire pour exécuter une application. C'est comme la maison construite, basée sur les pièces préfabriquées (Image).
5. Docker Hub (Hub Docker): Un service de registre basé sur le cloud qui vous permet de lier à des dépôts de code, de construire vos images et de les tester. C'est comme une présentation publique ou un stockage de diverses pièces de maison préfabriquées, qui peuvent être utilisées par n'importe quelle entreprise de construction (Moteur Docker).

Docker Swarm Docker में निर्मित एक कंटेनर ऑर्केस्ट्रेशन टूल है। यह आपको कई Docker होस्ट (नोड्स) को प्रबंधित करने और उन पर सेवाओं को इस तरह से तैनात करने की अनुमति देता है कि वे एक एकल, बड़े होस्ट की तरह कार्य करें। Swarm में नोड्स एक-दूसरे के साथ संवाद करते हैं ताकि यह सुनिश्चित हो सके कि वे आपके द्वारा तैनात सेवाओं की वांछित स्थिति बनाए रखें।

आइए इसे एक सादृश्य के साथ तोड़ें। Docker Swarm को एक ऑर्केस्ट्रा के कंडक्टर के रूप में सोचें, जहाँ प्रत्येक संगीतकार (Docker होस्ट/नोड) के पास निभाने के लिए एक विशिष्ट भूमिका (कार्य) है, और कंडक्टर (Docker Swarm) यह सुनिश्चित करता है कि हर कोई सुंदर संगीत (सुचारू रूप से चलने वाला एप्लिकेशन) बनाने के लिए सामंजस्य में खेले।

यहाँ एक Mermaid आरेख है जो बताता है कि Docker Swarm कैसे काम करता है:

graph LR
  DockerSwarm(Docker Swarm: Orchestra Conductor)
  DockerHost1(Docker Host 1: Musician 1)
  DockerHost2(Docker Host 2: Musician 2)
  DockerHost3(Docker Host 3: Musician 3)
  DockerSwarm --> DockerHost1
  DockerSwarm --> DockerHost2
  DockerSwarm --> DockerHost3

  subgraph ServicesOnHost1
  Service1a(Service 1: Musical Score 1)
  Service1b(Service 2: Musical Score 2)
  end

  subgraph ServicesOnHost2
  Service2a(Service 1: Musical Score 1)
  Service2b(Service 2: Musical Score 2)
  end

  subgraph ServicesOnHost3
  Service3a(Service 1: Musical Score 1)
  Service3b(Service 2: Musical Score 2)
  end

  DockerHost1 --> ServicesOnHost1
  DockerHost2 --> ServicesOnHost2
  DockerHost3 --> ServicesOnHost3

इस आरेख में:

• Docker Swarm: यह ऑर्केस्ट्रा का कंडक्टर है, जो प्रबंधित करता है कि प्रत्येक Docker होस्ट (या नोड) अपनी सेवाएं कैसे चलाता है।
• Docker होस्ट (1, 2, 3): ऑर्केस्ट्रा में संगीतकार, प्रत्येक संगीत स्कोर (सेवाओं) के अनुसार अपना हिस्सा बजा रहा है।
• सेवाएं (1, 2): संगीत स्कोर, जो उन विभिन्न कार्यों का प्रतिनिधित्व करते हैं जिन्हें प्रत्येक Docker होस्ट को करने की आवश्यकता होती है। प्रत्येक Docker होस्ट कई सेवाएं चला सकता है, ठीक वैसे ही जैसे एक संगीतकार संगीत के एक ही टुकड़े में अलग-अलग हिस्से बजा सकता है।

तीर Docker Swarm द्वारा Docker होस्ट को प्रबंधित करने का प्रतिनिधित्व करते हैं, जैसे एक कंडक्टर ऑर्केस्ट्रा में संगीतकारों को निर्देशित करता है, और प्रत्येक Docker होस्ट अपनी सेवाओं को प्रबंधित करता है, जैसे एक संगीतकार अपने संगीत स्कोर का पालन करता है।

Docker Swarm est un outil d'orchestration de conteneurs intégré à Docker. Il permet de gérer plusieurs hôtes Docker (nœuds) et de déployer des services sur ceux-ci de manière à ce qu'ils agissent comme un seul et grand hôte. Les nœuds d'un Swarm communiquent entre eux pour garantir qu'ils maintiennent l'état souhaité des services que vous déployez.

Prenons une analogie. Pensez à Docker Swarm comme à un chef d'orchestre, où chaque musicien (hôte Docker/nœud) a une partie spécifique à jouer (tâche), et le chef d'orchestre (Docker Swarm) veille à ce que tout le monde joue en harmonie pour créer une belle musique (application fonctionnant sans accroc).

Voici un diagramme Mermaid qui illustre comment fonctionne Docker Swarm:

graph LR
  DockerSwarm(Docker Swarm: Chef d'Orchestre)
  DockerHost1(Hôte Docker 1: Musicien 1)
  DockerHost2(Hôte Docker 2: Musicien 2)
  DockerHost3(Hôte Docker 3: Musicien 3)
  DockerSwarm --> DockerHost1
  DockerSwarm --> DockerHost2
  DockerSwarm --> DockerHost3

  subgraph ServicesOnHost1
  Service1a(Service 1: Partition Musicale 1)
  Service1b(Service 2: Partition Musicale 2)
  end

  subgraph ServicesOnHost2
  Service2a(Service 1: Partition Musicale 1)
  Service2b(Service 2: Partition Musicale 2)
  end

  subgraph ServicesOnHost3
  Service3a(Service 1: Partition Musicale 1)
  Service3b(Service 2: Partition Musicale 2)
  end

  DockerHost1 --> ServicesOnHost1
  DockerHost2 --> ServicesOnHost2
  DockerHost3 --> ServicesOnHost3

Dans ce diagramme :

• Docker Swarm: Il s'agit du chef d'orchestre, qui gère la façon dont chaque hôte Docker (ou nœud) exécute ses services.
• Hôtes Docker (1, 2, 3): Ce sont les musiciens de l'orchestre, chacun jouant son rôle en fonction des partitions musicales (services).
• Services (1, 2): Ce sont les partitions musicales, représentant les différentes tâches que chaque hôte Docker doit accomplir. Chaque hôte Docker peut exécuter plusieurs services, tout comme un musicien peut jouer différentes parties dans la même pièce musicale.

Les flèches représentent Docker Swarm qui gère les hôtes Docker, comme un chef d'orchestre dirigeant les musiciens dans un orchestre, et chaque hôte Docker gère ses services, comme un musicien suivant ses partitions musicales.

यहाँ एक उच्च-स्तरीय अवलोकन है:

1. सबसे पहले, अपने Django एप्लिकेशन के लिए एक Dockerfile बनाएं, जो आपके एप्लिकेशन की Docker इमेज बनाने के लिए ब्लूप्रिंट होगा।
2. फिर, एक Docker Compose फ़ाइल (docker-compose.yml) को परिभाषित करें, जो आपके एप्लिकेशन के लिए मल्टी-कंटेनर Docker वातावरण का वर्णन करेगी। इस फ़ाइल में आपके Django एप्लिकेशन कंटेनर और Postgres डेटाबेस कंटेनर के लिए कॉन्फ़िगरेशन शामिल होगा।
3. अंत में, अपने एप्लिकेशन को बनाने और शुरू करने के लिए Docker Compose कमांड का उपयोग करें।

graph TB
  DockerComposeFile[Docker Compose File]
  DockerComposeCommand{Docker Compose Commands}

  DockerComposeFile --> DjangoAppDockerFile[Django App Dockerfile]
  DjangoAppDockerFile --> DjangoAppImage[Django App Docker Image]
  DjangoAppImage --> DjangoAppContainer[Django App Container]

  DockerComposeFile --> PostgresImage[Postgres Docker Image]
  PostgresImage --> PostgresContainer[Postgres Container]

  DockerComposeCommand --> DockerComposeFile

  DjangoAppContainer -- Connects To --> PostgresContainer

  subgraph "Application Stack"
    DjangoAppContainer -- "Django Application" --> PostgresContainer
  end

यह आरेख प्रक्रिया का प्रतिनिधित्व करता है:

• Docker Compose फ़ाइल: इस फ़ाइल में आपके एप्लिकेशन के लिए मल्टी-कंटेनर Docker कॉन्फ़िगरेशन शामिल है।
• Docker Compose कमांड: ये वे कमांड हैं जिन्हें आप अपने Docker Compose वातावरण को शुरू करने के लिए चलाते हैं।
• Django App Dockerfile: यह आपके Django एप्लिकेशन के लिए Dockerfile है। यह आपके Django एप्लिकेशन की Docker इमेज बनाने के लिए एक ब्लूप्रिंट की तरह है।
• Django App Docker इमेज: यह आपके Django एप्लिकेशन के लिए Dockerfile से बनाई गई Docker इमेज है।
• Django App कंटेनर: यह आपके Django एप्लिकेशन को चलाने वाला Docker कंटेनर है। यह आपके Django एप्लिकेशन की Docker इमेज से बनाया गया है।
• Postgres Docker इमेज: यह Postgres डेटाबेस के लिए Docker इमेज है। इसे आमतौर पर Docker Hub से डाउनलोड किया जाता है।
• Postgres कंटेनर: यह आपके Postgres डेटाबेस को चलाने वाला Docker कंटेनर है। यह Postgres Docker इमेज से बनाया गया है।

Django App कंटेनर और Postgres कंटेनर नोड्स के बीच "Connects To" लेबल वाला तीर इंगित करता है कि Django एप्लिकेशन Postgres डेटाबेस से जुड़ता है।

"Application Stack" शीर्षक वाला सबग्राफ आपके पूर्ण एप्लिकेशन स्टैक का प्रतिनिधित्व करता है जिसमें Django एप्लिकेशन और Postgres डेटाबेस शामिल हैं।

Voici un aperçu de haut niveau :

1. Premièrement, créez un Dockerfile pour votre application Django, qui sera le plan pour construire une image Docker de votre application.
2. Ensuite, définissez un fichier Docker Compose (docker-compose.yml), qui décrira l'environnement Docker multi-conteneur pour votre application. Ce fichier inclura la configuration pour votre conteneur d'application Django et le conteneur de base de données Postgres.
3. Enfin, utilisez les commandes Docker Compose pour construire et démarrer votre application.

graph TB
  DockerComposeFile[Fichier Docker Compose]
  DockerComposeCommand{Commandes Docker Compose}

  DockerComposeFile --> DjangoAppDockerFile[Dockerfile App Django]
  DjangoAppDockerFile --> DjangoAppImage[Image Docker App Django]
  DjangoAppImage --> DjangoAppContainer[Conteneur App Django]

  DockerComposeFile --> PostgresImage[Image Docker Postgres]
  PostgresImage --> PostgresContainer[Conteneur Postgres]

  DockerComposeCommand --> DockerComposeFile

  DjangoAppContainer -- Se Connecte à --> PostgresContainer

  subgraph "Pile d'Applications"
    DjangoAppContainer -- "Application Django" --> PostgresContainer
  end

Ce diagramme représente le processus :

• Fichier Docker Compose : Ce fichier contient la configuration Docker multi-conteneur pour votre application.
• Commandes Docker Compose : Ce sont les commandes que vous exécutez pour démarrer votre environnement Docker Compose.
• Dockerfile App Django : C'est le Dockerfile pour votre application Django. C'est comme un plan pour créer une image Docker de votre application Django.
• Image Docker App Django : C'est l'image Docker créée à partir du Dockerfile pour votre application Django.
• Conteneur App Django : C'est le conteneur Docker exécutant votre application Django. Il est créé à partir de l'image Docker de votre application Django.
• Image Docker Postgres : C'est l'image Docker pour la base de données Postgres. Elle est généralement téléchargée depuis Docker Hub.
• Conteneur Postgres : C'est le conteneur Docker exécutant votre base de données Postgres. Il est créé à partir de l'image Docker Postgres.

La flèche étiquetée "Se Connecte à" entre les nœuds Conteneur App Django et Conteneur Postgres indique que l'application Django se connecte à la base de données Postgres.

Le sous-graphique intitulé "Pile d'Applications" représente votre pile d'applications complète, incluant l'application Django et la base de données Postgres.

प्रोजेक्ट में Dockerfile जोड़ें:

#+name Dockerfile

FROM python:3.10.6-bullseye

ENV PIP_NO_CACHE_DIR=True
ENV POETRY_VIRTUAL_ENVS_CREATE=False

RUN pip install -U \
    pip \
    setuptools \
    wheel \
    poetry

WORKDIR /app

RUN useradd -m -r user && \
    chown user /app

COPY pyproject.toml poetry.lock ./
#RUN poetry install --no-dev
#RUN poetry install --no-dev && \
#    rm -rf ~/.cache/pypoetry/{cache,artifacts}

RUN poetry export --without-hashes -f requirements.txt -o requirements.txt

RUN pip3 install -r requirements.txt

COPY . .

RUN python3 manage.py migrate

USER user
EXPOSE 8000/tcp

CMD ["python3", "manage.py", "runserver", "0.0.0.0:8000"]

कंटेनर बनाएं:

docker build -t mytodos:v1 ./

#+name fabfile.py

@task
def upload_and_install_docker_archive(ctx, server, docker_archive_src, docker_archive_dest):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:

        # Docker इमेज आर्काइव अपलोड करें
        conn.put(docker_archive_src, docker_archive_dest)

        # Docker आर्काइव इंस्टॉल करें
        conn.run(f'docker load -i {docker_archive_dest}')

#+name fabfile.py

@task
def remote_exec(ctx, server, cmd):

    # सर्वर कनेक्शन को परिभाषित करें
    with get_server_connection(server) as conn:

        # कमांड निष्पादित करें
        conn.run(cmd)

समाधान यह है:

docker buildx build --platform linux/amd64 -t mytodos:v1 ./

docker save mytodos:v2 > mytodos_app_container.tar

fab remote-exec ubuntu.main "docker swarm init"

#+name config.ini

[ubuntu.worker1]
host = ubuntu@35.183.61.2
app_dir = /home/ubuntu
pem_file = ubuntu-worker1.pem
token = SWMTKN-1-24z5u12objl9qho41g77nhkmds8qpjoea9ta8mpvfvwxojjs3y-2k5buiwingdxa97zalxu2076b 172.26.7.85:2377

#+name config.ini

[ubuntu.worker2]
host = ubuntu@15.156.205.168
app_dir = /home/ubuntu
pem_file = ubuntu-worker2.pem
token = SWMTKN-1-24z5u12objl9qho41g77nhkmds8qpjoea9ta8mpvfvwxojjs3y-2k5buiwingdxa97zalxu2076b 172.26.7.85:2377

docker swarm join --token SWMTKN-1-24z5u12objl9qho41g77nhkmds8qpjoea9ta8mpvfvwxojjs3y-2k5buiwingdxa97zalxu2076b 172.26.7.85:2377

docker node ls # Swarm क्लस्टर की जाँच करें

docker stack deploy -c docker-compose.yaml mytodos # mytodos सेवा नाम के साथ स्टैक तैनात करें

DATABASES = {
    "default": {
        "ENGINE": os.environ.get("SQL_ENGINE", "django.db.backends.sqlite3"),
        "NAME": os.environ.get("SQL_DATABASE", BASE_DIR / "db.sqlite3"),
        "USER": os.environ.get("SQL_USER", "user"),
        "PASSWORD": os.environ.get("SQL_PASSWORD", "password"),
        "HOST": os.environ.get("SQL_HOST", "localhost"),
        "PORT": os.environ.get("SQL_PORT", "5432"),
    }
}

#+name docker-compose.yaml

services:
  db:
    image: postgres
    volumes:
      - ./data/db:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
  web:
    image: mytodos:v3
    #build: .
    command: python manage.py runserver 0.0.0.0:8000
    #volumes:
    #  - .:/code
    ports:
      - "8000:8000"
    environment:
      - POSTGRES_NAME=postgres
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    depends_on:
      - db