KUNGFU TECH vietnam

Khóa học docker

Thực Hành Docker Với Kubernetes

0 phút đọc

Docker và Kubernetes là hai công nghệ quan trọng trong việc phát triển và triển khai các ứng dụng container hóa. Docker giúp đóng gói ứng dụng và các phụ thuộc của nó vào các container, trong khi Kubernetes cung cấp khả năng tự động hóa quy trình triển khai và quản lý các container này. Trong bài viết này, chúng ta sẽ tìm hiểu cách sử dụng Docker và Kubernetes để container hóa và triển khai một ứng dụng, bao gồm các bước từ cài đặt Docker và Kubernetes, tạo Dockerfile, xây dựng Docker image, chạy Docker container, và triển khai ứng dụng trên Kubernetes. Chúng ta cũng sẽ cung cấp các ví dụ cụ thể để minh họa.

Tổng Quan Về Docker và Kubernetes

Docker là một nền tảng cho phép bạn đóng gói ứng dụng và các phụ thuộc của nó vào một đơn vị tiêu chuẩn gọi là container. Container giúp đảm bảo rằng ứng dụng của bạn sẽ hoạt động nhất quán trên nhiều môi trường khác nhau, từ máy phát triển đến máy chủ sản xuất.

Kubernetes là một hệ thống điều phối container mã nguồn mở, giúp tự động hóa việc triển khai, quản lý và mở rộng các ứng dụng container hóa. Kubernetes cung cấp các cơ chế cơ bản cho việc triển khai, bảo trì và mở rộng các ứng dụng.

Các Bước Thực Hành Docker Với Kubernetes

Bước 1: Cài Đặt Docker và Kubernetes

Trước khi bắt đầu, bạn cần cài đặt Docker và Kubernetes trên máy của mình. Bạn có thể tải Docker từ trang web chính thức và làm theo hướng dẫn cài đặt cho hệ điều hành của bạn. Đối với Kubernetes, bạn có thể sử dụng Minikube để chạy Kubernetes trên máy tính cá nhân.

Bước 2: Tạo Ứng Dụng Node.js

Tạo một thư mục mới cho dự án Node.js của bạn và khởi tạo một dự án Node.js mới bằng cách sử dụng npm init.

mkdir my-node-app
cd my-node-app
npm init -y

Cài đặt các phụ thuộc cần thiết, ví dụ như Express:

npm install express

Tạo một file app.js với nội dung sau:

const express = require("express");
const app = express();
const port = 3000;

app.get("/", (req, res) => {
  res.send("Hello, Docker and Kubernetes!");
});

app.listen(port, () => {
  console.log(`App running at http://localhost:${port}`);
});

Bước 3: Tạo Dockerfile

Dockerfile là một file văn bản chứa các chỉ thị để Docker sử dụng nhằm tự động xây dựng một Docker image. Tạo một file có tên là Dockerfile trong thư mục gốc của dự án và thêm nội dung sau:

# Sử dụng image chính thức của Node.js làm base image
FROM node:14

# Tạo thư mục làm việc trong container
WORKDIR /usr/src/app

# Sao chép package.json và package-lock.json vào thư mục làm việc
COPY package*.json ./

# Cài đặt các phụ thuộc của ứng dụng
RUN npm install

# Sao chép mã nguồn ứng dụng vào thư mục làm việc
COPY . .

# Mở cổng 3000 để truy cập ứng dụng
EXPOSE 3000

# Chạy ứng dụng khi container khởi động
CMD ["node", "app.js"]

Bước 4: Tạo File .dockerignore

Tạo một file .dockerignore để loại bỏ các file không cần thiết khỏi build context, giúp giảm kích thước Docker image.

node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore

Bước 5: Xây Dựng Docker Image

Sử dụng lệnh docker build để xây dựng Docker image từ Dockerfile:

docker build -t my-node-app .

Trong lệnh này:

  • -t my-node-app: Đặt tên cho Docker image là my-node-app.
  • .: Đường dẫn đến Dockerfile.

Bước 6: Chạy Docker Container

Sử dụng lệnh docker run để tạo và chạy một container từ Docker image vừa xây dựng:

docker run -d -p 3000:3000 --name my-node-container my-node-app

Trong lệnh này:

  • -d: Chạy container ở chế độ nền (detached mode).
  • -p 3000:3000: Ánh xạ cổng 3000 trên host với cổng 3000 trên container.
  • --name my-node-container: Đặt tên cho container là my-node-container.

Bước 7: Tạo Kubernetes Deployment

Tạo một file có tên là deployment.yaml với nội dung sau:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: 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
          image: my-node-app:latest
          ports:
            - containerPort: 3000

Bước 8: Tạo Kubernetes Service

Tạo một file có tên là service.yaml với nội dung sau:

apiVersion: v1
kind: Service
metadata:
  name: my-node-app
spec:
  selector:
    app: my-node-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer

Bước 9: Triển Khai Ứng Dụng Trên Kubernetes

Sử dụng lệnh kubectl apply để triển khai ứng dụng trên Kubernetes:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Bước 10: Kiểm Tra Trạng Thái Ứng Dụng

Sử dụng lệnh kubectl get để kiểm tra trạng thái của deployment và service:

kubectl get deployments
kubectl get services

Các Thực Hành Tốt Nhất Khi Sử Dụng Docker Với Kubernetes

Sử Dụng Multi-Stage Builds

Multi-stage builds giúp giảm kích thước Docker image và cải thiện hiệu suất bằng cách tách biệt môi trường build và runtime.

Ví dụ về Dockerfile sử dụng multi-stage builds:

# Stage 1: Build
FROM node:14 AS build
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:14-alpine
WORKDIR /usr/src/app
COPY --from=build /usr/src/app .
EXPOSE 3000
CMD ["node", "app.js"]

Sử Dụng .dockerignore

Sử dụng file .dockerignore để loại bỏ các file không cần thiết khỏi build context, giúp giảm kích thước Docker image.

node_modules
npm-debug.log
Dockerfile
.dockerignore
.git
.gitignore

Chạy Container Với Quyền Hạn Thấp

Tránh chạy container với quyền root. Sử dụng chỉ thị USER để thiết lập người dùng không có quyền root.

RUN useradd -m myuser
USER myuser

Sử Dụng Environment Variables

Sử dụng biến môi trường để cấu hình ứng dụng Node.js của bạn.

Ví dụ về Dockerfile sử dụng biến môi trường:

FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
ENV NODE_ENV=production
CMD ["node", "app.js"]

Sử Dụng Docker Compose

Docker Compose cho phép bạn định nghĩa và quản lý các ứng dụng multi-container. Tạo một file docker-compose.yml với nội dung sau:

version: "3"
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - mysql
  mysql:
    image: "mysql:latest"
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: mydatabase
    ports:
      - "3306:3306"

Sử dụng lệnh docker-compose up để khởi động các dịch vụ:

docker-compose up

Ví Dụ: Tạo và Sử Dụng Docker Compose

Trong ví dụ này, chúng ta sẽ tạo và sử dụng Docker Compose để quản lý một ứng dụng Node.js và MySQL.

  1. Tạo Dockerfile Cho Ứng Dụng Web

    Tạo một file có tên là Dockerfile với nội dung sau:

    FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

  2. Tạo file package.json

    Tạo một file có tên là package.json với nội dung sau:

    {
  "name": "docker-example",
  "version": "1.0.0",
  "description": "A simple web application",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.17.1",
    "mysql": "^2.18.1"
  }
}

  3. Tạo file app.js

    Tạo một file có tên là app.js với nội dung sau:

    const express = require("express");
const mysql = require("mysql");
const app = express();
const port = 3000;

const db = mysql.createConnection({
  host: "mysql",
  user: "root",
  password: "example",
  database: "mydatabase",
});

db.connect((err) => {
  if (err) {
    console.error("Error connecting to MySQL:", err);
    return;
  }
  console.log("Connected to MySQL");
});

app.get("/", (req, res) => {
  res.send("Hello, Docker with MySQL!");
});

app.listen(port, () => {
  console.log(`App running at http://localhost:${port}`);
});

  4. Tạo Docker Compose File

    Tạo một file có tên là docker-compose.yml với nội dung sau:

    version: "3"
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - mysql
  mysql:
    image: "mysql:latest"
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: mydatabase
    ports:
      - "3306:3306"

  5. Khởi Động Các Dịch Vụ

    Sử dụng lệnh docker-compose up để khởi động các dịch vụ:

    docker-compose up

  6. Truy Cập Ứng Dụng

    Mở trình duyệt web và truy cập http://localhost:3000. Bạn sẽ thấy thông báo "Hello, Docker with MySQL!".

Kết Luận

Thực hành Docker với Kubernetes là một kỹ năng quan trọng giúp bạn đảm bảo rằng ứng dụng của mình sẽ hoạt động nhất quán và an toàn trên nhiều môi trường khác nhau. Bằng cách sử dụng các công cụ và phương pháp như Dockerfile, Docker Compose, và các thực hành tốt nhất, bạn có thể dễ dàng quản lý và tối ưu hóa các container Docker của mình. Việc hiểu rõ cách thiết lập và sử dụng Docker và Kubernetes sẽ giúp bạn tận dụng tối đa các lợi ích mà hai công nghệ này mang lại. Bằng cách tuân theo các thực hành tốt nhất, bạn có thể đảm bảo rằng ứng dụng của mình sẽ hoạt động hiệu quả và bảo mật.

Avatar
Được viết bởi

TechMely Team

Gợi ý câu hỏi phỏng vấn

Gợi ý bài viết

Bình luận

Chưa có bình luận nào

Khoá học javascript từ cơ bản đến chuyên sâuYoutube Techmely