డాకర్ ప్రారంభ గైడ్: మీ అప్లికేషన్‌ను కంటైనరైజ్ చేయడానికి త్వరగా ప్రారంభించండి

# డాకర్ ప్రారంభ గైడ్: మీ అప్లికేషన్‌ను కంటైనరైజ్ చేయడానికి త్వరగా ప్రారంభించండి

డాకర్ ఆధునిక సాఫ్ట్‌వేర్ అభివృద్ధి మరియు విస్తరణలో ఒక ముఖ్యమైన భాగంగా మారింది. Kubernetes గురించిన చర్చలు విస్తృతంగా ఉన్నప్పటికీ, అనేక కంపెనీలు అప్లికేషన్‌లను నిర్మించడానికి, పరీక్షించడానికి మరియు విస్తరించడానికి డాకర్‌ను ఇష్టపడతాయి. ఈ ఆర్టికల్ డాకర్‌తో త్వరగా ప్రారంభించడానికి, దాని ప్రధాన అంశాలను అర్థం చేసుకోవడానికి మరియు మీ అప్లికేషన్‌ను కంటైనరైజ్ చేయడానికి మీకు సహాయపడే ఆచరణాత్మక ఉదాహరణను అందిస్తుంది.

## డాకర్ ప్రధాన అంశాలు

మీరు ప్రాక్టీస్ ప్రారంభించే ముందు, డాకర్ యొక్క కొన్ని ప్రధాన అంశాలను అర్థం చేసుకోవడం చాలా ముఖ్యం:

*   **ఇమేజ్ (Image):** ఇమేజ్ అనేది చదవడానికి మాత్రమే ఉండే టెంప్లేట్, ఇది అప్లికేషన్‌ను అమలు చేయడానికి అవసరమైన ప్రతిదాన్ని కలిగి ఉంటుంది: కోడ్, రన్ టైమ్ ఎన్విరాన్‌మెంట్, సిస్టమ్ టూల్స్, లైబ్రరీలు మరియు డిపెండెన్సీలు. ఇది వర్చువల్ మెషిన్ ఇమేజ్‌ను పోలి ఉంటుంది, కానీ తేలికైనది.

*   **కంటైనర్ (Container):** కంటైనర్ అనేది ఇమేజ్ నుండి సృష్టించబడిన రన్నింగ్ ఇన్స్టాన్స్. ఇది ఇమేజ్ యొక్క రన్ టైమ్ ఇన్స్టాన్స్, ఇందులో అప్లికేషన్ మరియు దాని డిపెండెన్సీలు ఉంటాయి. కంటైనర్‌లు ఒకదానికొకటి వేరు చేయబడతాయి మరియు వాటి స్వంత ఫైల్ సిస్టమ్, ప్రాసెస్ మరియు నెట్‌వర్క్ స్థలాన్ని కలిగి ఉంటాయి.

*   **డాకర్ హబ్ (Docker Hub):** డాకర్ హబ్ అనేది పబ్లిక్ ఇమేజ్ రిపోజిటరీ, ఇక్కడ మీరు ముందుగా నిర్మించిన ఇమేజ్‌లను డౌన్‌లోడ్ చేసుకోవచ్చు లేదా మీ స్వంత ఇమేజ్‌లను అప్‌లోడ్ చేయవచ్చు. ఇది GitHub లాంటిది, కానీ డాకర్ ఇమేజ్‌ల కోసం ప్రత్యేకంగా రూపొందించబడింది.

*   **డాకర్‌ఫైల్ (Dockerfile):** డాకర్‌ఫైల్ అనేది డాకర్ ఇమేజ్‌ను నిర్మించడానికి అన్ని సూచనలను కలిగి ఉన్న టెక్స్ట్ ఫైల్. డాకర్‌ఫైల్‌ను వ్రాయడం ద్వారా, మీరు ఇమేజ్ సృష్టి ప్రక్రియను ఆటోమేట్ చేయవచ్చు.

*   **డాకర్ కంపోజ్ (Docker Compose):** డాకర్ కంపోజ్ అనేది మల్టీ-కంటైనర్ డాకర్ అప్లికేషన్‌లను నిర్వచించడానికి మరియు అమలు చేయడానికి ఒక సాధనం. ఇది YAML ఫైల్‌ను ఉపయోగించి అప్లికేషన్ యొక్క సేవలను కాన్ఫిగర్ చేయడానికి మరియు ఒకే ఆదేశంతో అన్ని సేవలను ప్రారంభించడానికి లేదా ఆపడానికి మిమ్మల్ని అనుమతిస్తుంది.

## డాకర్ సంస్థాపన

మొదట, మీరు డాకర్‌ను ఇన్స్టాల్ చేయాలి. డాకర్ వివిధ ఆపరేటింగ్ సిస్టమ్‌ల కోసం ఇన్స్టాలేషన్ ప్యాకేజీలను అందిస్తుంది. [డాకర్ అధికారిక వెబ్‌సైట్‌ను](https://www.docker.com/get-started/) సందర్శించండి మరియు సంబంధిత సూచనలను అనుసరించి ఇన్స్టాల్ చేయండి.

సంస్థాపన పూర్తయిన తర్వాత, డాకర్ సరిగ్గా ఇన్స్టాల్ చేయబడిందో లేదో ధృవీకరించడానికి `docker --version` ఆదేశాన్ని అమలు చేయవచ్చు.

## సాధారణ పైథాన్ అప్లికేషన్‌ను కంటైనరైజ్ చేయడం

మేము ఒక సాధారణ పైథాన్ అప్లికేషన్‌ను సృష్టిస్తాము మరియు డాకర్‌ను ఉపయోగించి దానిని కంటైనరైజ్ చేస్తాము.

### 1. పైథాన్ అప్లికేషన్‌ను సృష్టించండి

కింది కోడ్‌తో `app.py` అనే ఫైల్‌ను సృష్టించండి:

```python
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

ఈ సాధారణ Flask అప్లికేషన్ రూట్ పాత్ / లో "Hello, Docker!" ను అందిస్తుంది.

2. requirements.txt ఫైల్‌ను సృష్టించండి

అప్లికేషన్ Flask లైబ్రరీపై ఆధారపడి ఉంటుంది, ఈ డిపెండెన్సీలను ప్రకటించడానికి మనం requirements.txt ఫైల్‌ను సృష్టించాలి.

Flask

3. డాకర్‌ఫైల్‌ను సృష్టించండి

Dockerfile అనే ఫైల్‌ను సృష్టించండి మరియు కింది వాటిని జోడించండి:

# అధికారిక పైథాన్ ఇమేజ్‌ను బేస్ ఇమేజ్‌గా ఉపయోగించండి
FROM python:3.9-slim-buster

# పని చేసే డైరెక్టరీని సెట్ చేయండి
WORKDIR /app

# requirements.txt ఫైల్‌ను పని చేసే డైరెక్టరీకి కాపీ చేయండి
COPY requirements.txt .

# డిపెండెన్సీలను ఇన్స్టాల్ చేయండి
RUN pip install --no-cache-dir -r requirements.txt
```# అప్లికేషన్ కోడ్‌ను పని చేసే డైరెక్టరీకి కాపీ చేయండి
COPY app.py .

# పోర్ట్ 5000ని బహిర్గతం చేయండి
EXPOSE 5000

# ప్రారంభ ఆదేశాన్ని నిర్వచించండి
CMD ["python", "app.py"]

Dockerfile వివరణ:

• FROM python:3.9-slim-buster: బేస్ ఇమేజ్‌ను Python 3.9 యొక్క స్లిమ్ వెర్షన్‌గా పేర్కొంటుంది.
• WORKDIR /app: కంటైనర్‌లోని పని చేసే డైరెక్టరీని /appగా సెట్ చేస్తుంది.
• COPY requirements.txt .: ప్రస్తుత డైరెక్టరీలోని requirements.txt ఫైల్‌ను కంటైనర్‌లోని /app డైరెక్టరీకి కాపీ చేస్తుంది.
• RUN pip install --no-cache-dir -r requirements.txt: కంటైనర్‌లో pip ఆదేశాన్ని అమలు చేయడం ద్వారా requirements.txt ఫైల్‌లో పేర్కొన్న డిపెండెన్సీలను ఇన్‌స్టాల్ చేస్తుంది. --no-cache-dir పరామితి ఇమేజ్ పరిమాణాన్ని తగ్గిస్తుంది.
• COPY app.py .: ప్రస్తుత డైరెక్టరీలోని app.py ఫైల్‌ను కంటైనర్‌లోని /app డైరెక్టరీకి కాపీ చేస్తుంది.
• EXPOSE 5000: కంటైనర్ 5000 పోర్ట్‌ను వింటుందని ప్రకటిస్తుంది.
• CMD ["python", "app.py"]: కంటైనర్ ప్రారంభించినప్పుడు అమలు చేయాల్సిన ఆదేశాన్ని నిర్వచిస్తుంది.

4. Docker ఇమేజ్‌ను నిర్మించండి

Dockerfile ఉన్న డైరెక్టరీలో, Docker ఇమేజ్‌ను నిర్మించడానికి ఈ క్రింది ఆదేశాన్ని అమలు చేయండి:

docker build -t my-python-app .

• docker build: ఇమేజ్‌ను నిర్మించే ఆదేశం.
• -t my-python-app: ఇమేజ్‌కు పేరును కేటాయిస్తుంది (my-python-app).
• .: Dockerfile ఉన్న డైరెక్టరీని (ప్రస్తుత డైరెక్టరీ) పేర్కొంటుంది.

నిర్మాణ ప్రక్రియ నెట్‌వర్క్ వేగం మరియు డిపెండెన్సీల పరిమాణంపై ఆధారపడి కొంత సమయం పట్టవచ్చు.

5. Docker కంటైనర్‌ను అమలు చేయండి

Docker కంటైనర్‌ను అమలు చేయడానికి ఈ క్రింది ఆదేశాన్ని ఉపయోగించండి:

docker run -d -p 5000:5000 my-python-app

• docker run: కంటైనర్‌ను అమలు చేసే ఆదేశం.
• -d: వేరు చేయబడిన మోడ్‌లో కంటైనర్‌ను అమలు చేస్తుంది (నేపథ్యంలో రన్ అవుతుంది).
• -p 5000:5000: హోస్ట్ మెషిన్ యొక్క 5000 పోర్ట్‌ను కంటైనర్ యొక్క 5000 పోర్ట్‌కు మ్యాప్ చేస్తుంది.
• my-python-app: ఉపయోగించాల్సిన ఇమేజ్ పేరును పేర్కొంటుంది.

6. అప్లికేషన్‌ను ధృవీకరించండి

బ్రౌజర్‌లో http://localhost:5000ని సందర్శించండి, మీకు "Hello, Docker!" కనిపిస్తుంది.

7. కంటైనర్‌ను ఆపివేసి, తొలగించండి

కంటైనర్‌ను ఆపడానికి ఈ క్రింది ఆదేశాన్ని ఉపయోగించండి:

docker stop 

`` docker ps ఆదేశాన్ని ఉపయోగించి కనుగొనవచ్చు.

కంటైనర్‌ను తొలగించడానికి ఈ క్రింది ఆదేశాన్ని ఉపయోగించండి:

docker rm 

Docker Compose పరిచయం

మీ అప్లికేషన్ బహుళ సేవలతో రూపొందించబడితే, వాటిని నిర్వహించడానికి మీరు Docker Composeని ఉపయోగించవచ్చు.

1. docker-compose.yml ఫైల్‌ను సృష్టించండి

docker-compose.yml పేరుతో ఒక ఫైల్‌ను సృష్టించండి మరియు ఈ క్రింది కంటెంట్‌ను జోడించండి:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

docker-compose.yml వివరణ:* version: "3.9": డాకర్ కంపోజ్ ఫైల్ యొక్క సంస్కరణను పేర్కొంటుంది.

• services: అప్లికేషన్ యొక్క సేవలను నిర్వచిస్తుంది.
• web: "web" అనే పేరుతో ఒక సేవను నిర్వచిస్తుంది.
• image: my-python-app: సేవ ఉపయోగించే ఇమేజ్‌ను పేర్కొంటుంది.
• ports: పోర్ట్ మ్యాపింగ్‌లను నిర్వచిస్తుంది.

2. అప్లికేషన్‌ను ప్రారంభించండి

docker-compose.yml ఫైల్ ఉన్న డైరెక్టరీలో, అప్లికేషన్‌ను ప్రారంభించడానికి ఈ క్రింది ఆదేశాన్ని అమలు చేయండి:

docker-compose up -d

• docker-compose up: అప్లికేషన్‌ను ప్రారంభించే ఆదేశం.
• -d: కంటైనర్‌లను వేరు చేయబడిన మోడ్‌లో అమలు చేస్తుంది.

3. అప్లికేషన్‌ను ఆపండి

అప్లికేషన్‌ను ఆపడానికి ఈ క్రింది ఆదేశాన్ని ఉపయోగించండి:

docker-compose down

డాకర్ భద్రతా ఉత్తమ పద్ధతులు

చర్చ నుండి చూసినట్లుగా, డాకర్ ఇమేజ్‌ల భద్రత ఒక ముఖ్యమైన సమస్య. ఇక్కడ కొన్ని డాకర్ భద్రతా ఉత్తమ పద్ధతులు ఉన్నాయి:

• అధికారిక ఇమేజ్‌లను ఉపయోగించండి: సాధ్యమైనంతవరకు అధికారికంగా అందించబడిన ఇమేజ్‌లను ఉపయోగించండి, ఈ ఇమేజ్‌లు సాధారణంగా భద్రతా స్కాన్ మరియు నిర్వహణ చేయబడతాయి.
• ఇమేజ్ బలహీనతలను స్కాన్ చేయండి: ట్రివీ వంటి సాధనాలను ఉపయోగించి ఇమేజ్‌లలో తెలిసిన బలహీనతలను స్కాన్ చేయండి మరియు ఇమేజ్‌లను సకాలంలో నవీకరించండి.
• కనీస అనుమతుల సూత్రాన్ని ఉపయోగించండి: రూట్ యూజర్‌గా కంటైనర్‌లను అమలు చేయడం మానుకోండి.
• కంటైనర్ వనరులను పరిమితం చేయండి: cgroups ఉపయోగించి కంటైనర్ యొక్క CPU మరియు మెమరీ వినియోగాన్ని పరిమితం చేయండి.
• క్రమం తప్పకుండా ఇమేజ్‌లను నవీకరించండి: భద్రతా లోపాలను పరిష్కరించడానికి ఇమేజ్‌లను తాజాగా ఉంచండి.
• భద్రతా స్కానింగ్ సాధనాలను ఉపయోగించండి: Snyk, Clair వంటి సాధనాలను మీ CI/CD ప్రక్రియలో విలీనం చేయవచ్చు, ఇవి ఇమేజ్ బలహీనతలను స్వయంచాలకంగా స్కాన్ చేస్తాయి.

ముగింపుఈ కథనం డాకర్‌కు శీఘ్ర ప్రారంభ మార్గదర్శినిని అందిస్తుంది, ఇది ప్రధాన భావనలు, సంస్థాపన దశలు మరియు సాధారణ పైథాన్ అప్లికేషన్ యొక్క కంటైనరైజేషన్ ఉదాహరణను కలిగి ఉంటుంది. ఈ ప్రాథమిక అంశాలను నేర్చుకోవడం ద్వారా, మీరు మీ అప్లికేషన్‌లను రూపొందించడానికి, పరీక్షించడానికి మరియు అమలు చేయడానికి డాకర్‌ను ఉపయోగించడం ప్రారంభించవచ్చు. గుర్తుంచుకోండి, భద్రత చాలా ముఖ్యం, ఎల్లప్పుడూ Docker ఇమేజ్ భద్రతపై శ్రద్ధ వహించండి మరియు మీ అప్లికేషన్‌ను రక్షించడానికి తగిన చర్యలు తీసుకోండి. Kubernetes పెద్ద ఎత్తున కంటైనర్ ఆర్కెస్ట్రేషన్ విషయంలో శక్తివంతమైనది అయినప్పటికీ, Docker అనేక సందర్భాల్లో ఇప్పటికీ సరళమైన మరియు సమర్థవంతమైన పరిష్కారం. డాకర్‌పై పట్టు సాధించడం ద్వారా, మీరు ఆధునిక సాఫ్ట్‌వేర్ అభివృద్ధి మరియు అమలు సవాళ్లను బాగా ఎదుర్కోగలరు.