# Docker Introduktion: Kom igång snabbt med att containerisera din applikation

Docker har blivit en oumbärlig del av modern mjukvaruutveckling och driftsättning. Trots den överväldigande diskussionen kring Kubernetes, är Docker fortfarande det föredragna verktyget för många företag för att bygga, testa och driftsätta applikationer. Den här artikeln kommer att ge dig en snabb introduktion till Docker, förstå dess kärnkoncept och ge ett praktiskt exempel för att hjälpa dig komma igång med att containerisera din applikation.

## Docker Kärnkoncept

Innan du börjar praktisera är det viktigt att förstå några av Dockers kärnkoncept:

*   **Image (Avbildning):** En avbildning är en skrivskyddad mall som innehåller allt som behövs för att köra en applikation: kod, körtidsmiljö, systemverktyg, bibliotek och beroenden. Liknar en virtuell maskin-avbildning, men är lättare.

*   **Container (Container):** En container är en körande instans skapad från en avbildning. Det är en körtidsinstans av en avbildningen, som innehåller applikationen och alla dess beroenden. Containrar är isolerade från varandra och har sina egna filsystem, processer och nätverksutrymmen.

*   **Docker Hub:** Docker Hub är ett offentligt avbildningsarkiv där du kan ladda ner förbyggda avbildningar och ladda upp dina egna avbildningar. Liknar GitHub, men är specifikt för Docker-avbildningar.

*   **Dockerfile:** En Dockerfile är en textfil som innehåller alla instruktioner för att bygga en Docker-avbildning. Genom att skriva en Dockerfile kan du automatisera skapandet av avbildningen.

*   **Docker Compose:** Docker Compose är ett verktyg för att definiera och köra Docker-applikationer med flera containrar. Det låter dig konfigurera applikationens tjänster med en YAML-fil och sedan starta eller stoppa alla tjänster med ett enda kommando.

## Docker Installation

Först måste du installera Docker. Docker erbjuder installationspaket för olika operativsystem. Besök [Docker officiella webbplats](https://www.docker.com/get-started/) och följ motsvarande instruktioner för att installera.

När installationen är klar kan du verifiera att Docker är korrekt installerat genom att köra kommandot `docker --version`.

## Containerisera en enkel Python-applikation

Vi kommer att skapa en enkel Python-applikation och använda Docker för att containerisera den.

### 1. Skapa Python-applikationen

Skapa en fil med namnet `app.py` som innehåller följande kod:

```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')

Denna enkla Flask-applikation kommer att returnera "Hello, Docker!" på rotvägen /.

2. Skapa filen requirements.txt

Applikationen är beroende av Flask-biblioteket, vi måste skapa en requirements.txt-fil för att deklarera dessa beroenden.

Flask

3. Skapa Dockerfile

Skapa en fil med namnet Dockerfile och lägg till följande innehåll:

# Använd den officiella Python-avbildningen som basavbildning
FROM python:3.9-slim-buster

# Ange arbetskatalog
WORKDIR /app

# Kopiera filen requirements.txt till arbetskatalogen
COPY requirements.txt .

# Installera beroenden
RUN pip install --no-cache-dir -r requirements.txt

Kopiera applikationskoden till arbetskatalogen

COPY app.py .

Exponera port 5000

EXPOSE 5000

Definiera startkommandot

CMD ["python", "app.py"]

**Dockerfile Förklaring:**

*   `FROM python:3.9-slim-buster`: Specificerar basavbildningen som en slimmad version av Python 3.9.
*   `WORKDIR /app`: Sätter arbetskatalogen inuti containern till `/app`.
*   `COPY requirements.txt .`: Kopierar filen `requirements.txt` från den aktuella katalogen till `/app`-katalogen i containern.
*   `RUN pip install --no-cache-dir -r requirements.txt`: Kör `pip`-kommandot inuti containern för att installera de beroenden som specificeras i filen `requirements.txt`. Parametern `--no-cache-dir` kan minska storleken på avbildningen.
*   `COPY app.py .`: Kopierar filen `app.py` från den aktuella katalogen till `/app`-katalogen i containern.
*   `EXPOSE 5000`: Deklarerar att containern kommer att lyssna på port 5000.
*   `CMD ["python", "app.py"]`: Definierar kommandot som ska köras när containern startar.

### 4. Bygg Docker-avbildningen

I katalogen som innehåller `Dockerfile`, kör följande kommando för att bygga Docker-avbildningen:

```bash
docker build -t my-python-app .

• docker build: Kommandot för att bygga avbildningen.
• -t my-python-app: Anger ett namn (my-python-app) för avbildningen.
• .: Anger katalogen där Dockerfile finns (den aktuella katalogen).

Byggprocessen kan ta lite tid, beroende på nätverkshastighet och storleken på beroendena.

5. Kör Docker-containern

Använd följande kommando för att köra Docker-containern:

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

• docker run: Kommandot för att köra containern.
• -d: Kör containern i fristående läge (körs i bakgrunden).
• -p 5000:5000: Mappar värddatorns port 5000 till containerns port 5000.
• my-python-app: Anger namnet på avbildningen som ska användas.

6. Verifiera applikationen

I en webbläsare, besök http://localhost:5000, du bör se "Hello, Docker!".

7. Stoppa och ta bort containern

Använd följande kommando för att stoppa containern:

docker stop 

`` kan hittas med kommandot docker ps.

Använd följande kommando för att ta bort containern:

docker rm 

Docker Compose Kom Igång

Om din applikation består av flera tjänster kan du använda Docker Compose för att hantera dem.

1. Skapa filen docker-compose.yml

Skapa en fil med namnet docker-compose.yml och lägg till följande innehåll:

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

docker-compose.yml Förklaring:* version: "3.9": Anger versionen av Docker Compose-filen.

• services: Definierar applikationens tjänster.
• web: Definierar en tjänst med namnet "web".
• image: my-python-app: Anger vilken image tjänsten ska använda.
• ports: Definierar portmappningar.

2. Starta applikationen

I katalogen som innehåller docker-compose.yml-filen, kör följande kommando för att starta applikationen:

docker-compose up -d

• docker-compose up: Kommandot för att starta applikationen.
• -d: Kör containern i fristående läge (detached mode).

3. Stoppa applikationen

Använd följande kommando för att stoppa applikationen:

docker-compose down

Docker Säkerhetsbästa Praxis

Som framgår av diskussionen är säkerheten för Docker-images en viktig fråga. Här är några Docker säkerhetsbästa praxis:

• Använd officiella images: Använd om möjligt officiellt tillhandahållna images, eftersom dessa vanligtvis har genomgått säkerhetsskanningar och underhålls.
• Skanna images efter sårbarheter: Använd verktyg som Trivy för att skanna images efter kända sårbarheter och uppdatera images i tid.
• Använd principen om minsta behörighet: Undvik att köra containrar som root-användare.
• Begränsa containerresurser: Använd cgroups för att begränsa containerns CPU- och minnesanvändning.
• Uppdatera images regelbundet: Håll images uppdaterade för att åtgärda säkerhetssårbarheter.
• Använd säkerhetsskanningsverktyg: Verktyg som Snyk, Clair etc. kan integreras i din CI/CD-process för att automatiskt skanna images efter sårbarheter.

SlutsatsDen här artikeln ger en snabbstartsguide för Docker, som täcker kärnkoncept, installationssteg och ett enkelt exempel på containerisering av en Python-applikation. Genom att lära dig dessa grunder kan du börja använda Docker för att bygga, testa och distribuera dina applikationer. Kom ihåg att säkerhet är avgörande, var alltid uppmärksam på säkerheten i Docker-avbildningar och vidta lämpliga åtgärder för att skydda dina applikationer. Även om Kubernetes är kraftfullt för storskalig containerorkestrering, är Docker fortfarande en enkel och effektiv lösning i många scenarier. Genom att behärska Docker kan du bättre möta utmaningarna med modern mjukvaruutveckling och distribution.