Tutorijal: Kontejnerizacija i orkestracija

Uvod u Kontejnerizaciju i Orkestraciju za DevOps inženjere

Kontejnerizacija i orkestracija su transformisale način na koji se softver razvija, deployuje i upravlja. Kontejneri, poput Dockera, omogućavaju pakovanje aplikacija i svih njihovih zavisnosti u izolovanu jedinicu, obezbeđujući konzistentno okruženje od razvoja do produkcije. Orkestracioni alati, kao što je Kubernetes, automatizuju upravljanje kontejnerizovanim aplikacijama na velikoj skali, uključujući deployment, skaliranje, mrežu i monitoring. Za DevOps inženjera, duboko razumevanje ovih tehnologija je neophodno za izgradnju modernih, skalabilnih i otpornih sistema. Ovaj tutorijal će vas provesti kroz ključne koncepte Dockera i Kubernetes-a, sa praktičnim primerima.

Zašto su kontejnerizacija i orkestracija ključne u DevOps-u?

Docker - Osnove kontejnerizacije

Docker je najpopularnija platforma za kontejnerizaciju. Omogućava vam da gradite, pokrećete i delite kontejnerizovane aplikacije.

Ključni koncepti Dockera

Osnovne Docker komande

Praktičan primer: Kontejnerizacija jednostavne web aplikacije

Pretpostavimo da imamo jednostavnu Node.js aplikaciju (app.js):

const http = require("http");

const hostname = "0.0.0.0";
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");
  res.end("Hello from Docker!\n");
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

I package.json:

{
  "name": "my-node-app",
  "version": "1.0.0",
  "description": "A simple Node.js web app",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "author": "",
  "license": "ISC"
}

Dockerfile:

# Koristi zvaničnu Node.js sliku kao baznu sliku
FROM node:18-alpine

# Postavi radni direktorijum unutar kontejnera
WORKDIR /app

# Kopiraj package.json i package-lock.json u radni direktorijum
COPY package*.json ./

# Instaliraj zavisnosti
RUN npm install

# Kopiraj ostatak koda aplikacije u radni direktorijum
COPY . .

# Izloži port na kojem aplikacija sluša
EXPOSE 3000

# Komanda za pokretanje aplikacije kada se kontejner pokrene
CMD ["npm", "start"]

Koraci za izgradnju i pokretanje:

  1. Sačuvajte gornje fajlove u istom direktorijumu.
  2. Izgradite sliku: bash docker build -t my-node-app .
  3. Pokrenite kontejner: bash docker run -p 80:3000 my-node-app Sada možete pristupiti aplikaciji putem http://localhost u vašem pretraživaču.

Docker Compose za multi-kontejnerske aplikacije

Docker Compose je alat za definisanje i pokretanje multi-kontejnerskih Docker aplikacija. Koristi YAML fajl za konfiguraciju servisa aplikacije, što omogućava pokretanje celog stack-a jednom komandom.

Ključni koncepti Docker Compose-a

Osnovne Docker Compose komande

Praktičan primer: Web aplikacija sa bazom podataka (Node.js + MongoDB)

docker-compose.yml:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "80:3000"
    depends_on:
      - db
    environment:
      MONGO_URI: mongodb://db:27017/mydb
  db:
    image: mongo:latest
    volumes:
      - mongo-data:/data/db

volumes:
  mongo-data:

app.js (primer sa MongoDB konekcijom):

const http = require("http");
const MongoClient = require('mongodb').MongoClient;

const hostname = "0.0.0.0";
const port = 3000;
const mongoUri = process.env.MONGO_URI || 'mongodb://localhost:27017/mydb';

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader("Content-Type", "text/plain");

  MongoClient.connect(mongoUri, { useNewUrlParser: true, useUnifiedTopology: true }, (err, client) => {
    if (err) {
      console.error("Failed to connect to MongoDB", err);
      res.end("Hello from Docker! Failed to connect to DB.\n");
      return;
    }
    const db = client.db();
    db.collection('messages').insertOne({ text: 'Hello from Node.js' }, (err, result) => {
      if (err) {
        console.error("Failed to insert message", err);
        res.end("Hello from Docker! Failed to insert message.\n");
        client.close();
        return;
      }
      res.end("Hello from Docker! Message inserted into DB.\n");
      client.close();
    });
  });
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

package.json (dodajte mongodb zavisnost):

{
  "name": "my-node-app",
  "version": "1.0.0",
  "description": "A simple Node.js web app",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "mongodb": "^4.0.0"
  }
}

Koraci za pokretanje:

  1. Sačuvajte Dockerfile, app.js i package.json u direktorijumu web/.
  2. Sačuvajte docker-compose.yml u roditeljskom direktorijumu web/.
  3. Pokrenite aplikaciju: bash docker-compose up -d Sada imate web aplikaciju i MongoDB bazu podataka pokrenute u odvojenim kontejnerima, povezanih putem Docker Compose-a.

Kubernetes - Orkestracija kontejnera

Kubernetes je open-source sistem za automatizaciju deploymenta, skaliranja i upravljanja kontejnerizovanim aplikacijama. Postao je de facto standard za orkestraciju kontejnera u produkcionim okruženjima.

Ključni koncepti Kubernetes-a

Osnovne kubectl komande

Praktičan primer: Deployment web aplikacije na Kubernetes

Koristićemo istu Node.js aplikaciju kao ranije, ali ćemo je deployovati na Kubernetes.

deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-node-app-deployment
  labels:
    app: my-node-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-node-app
  template:
    metadata:
      labels:
        app: my-node-app
    spec:
      containers:
      - name: my-node-app-container
        image: your_docker_username/my-node-app:latest # Koristite vašu Docker sliku
        ports:
        - containerPort: 3000

service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: my-node-app-service
spec:
  selector:
    app: my-node-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer # Koristite LoadBalancer za eksterni pristup u cloudu, ili NodePort za lokalni klaster

Koraci za deployment:

  1. Izgradite i pushujte Docker sliku na Docker Hub (ili drugi registar): bash docker build -t your_docker_username/my-node-app:latest . docker push your_docker_username/my-node-app:latest
  2. Primijenite Deployment i Service na vaš Kubernetes klaster: bash kubectl apply -f deployment.yaml kubectl apply -f service.yaml
  3. Proverite status Podova i Servisa: bash kubectl get pods kubectl get services
  4. Pristupite aplikaciji koristeći eksternu IP adresu LoadBalancer Servisa (može potrajati nekoliko minuta da se dodeli).

Helm za pakovanje Kubernetes aplikacija

Helm je menadžer paketa za Kubernetes. Omogućava vam da definišete, instalirate i nadogradite čak i najkompleksnije Kubernetes aplikacije koristeći Helm Charts.

Ključni koncepti Helm-a

Osnovne Helm komande

Praktičan primer: Deployment aplikacije sa Helm-om

  1. Kreirajte Helm Chart za vašu Node.js aplikaciju: bash helm create my-node-app-chart
  2. Izmenite my-node-app-chart/values.yaml da konfigurišete sliku i port: yaml image: repository: your_docker_username/my-node-app tag: latest service: type: LoadBalancer port: 80 targetPort: 3000
  3. Izmenite my-node-app-chart/templates/deployment.yaml i my-node-app-chart/templates/service.yaml da koriste ove vrednosti.
  4. Instalirajte Chart: bash helm install my-node-app-release ./my-node-app-chart

Zaključak

Kontejnerizacija sa Dockerom i orkestracija sa Kubernetesom su postale nezaobilazne tehnologije u modernom DevOps pejzažu. One omogućavaju timovima da grade, deployuju i upravljaju aplikacijama na efikasan, skalabilan i pouzdan način. Ovladavanje ovim alatima će vas pozicionirati kao ključnog igrača u svakom DevOps timu. Kontinuirano eksperimentisanje sa ovim tehnologijama i praćenje novih trendova je ključno za vaš dalji razvoj.

Reference

Autor: Manus AI Datum: 27. jul 2025.