docker和k8s实践

news2025/1/3 10:46:01

Docker 和 Kubernetes 是现代云原生应用开发和运维中的两个重要技术。Docker 提供容器化技术，可以将应用及其依赖打包在容器中，而 Kubernetes 则负责容器的编排、部署、伸缩和管理。以下是 Docker 和 Kubernetes 的实践指南，涵盖基础安装、配置和常见操作。

1. Docker 实践

1.1 安装 Docker

在 Linux (例如 AlmaLinux) 上安装 Docker：

# 安装 Docker 的依赖包
sudo dnf install -y yum-utils device-mapper-persistent-data lvm2

# 设置 Docker 仓库
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# 安装 Docker Engine
sudo dnf install docker-ce docker-ce-cli containerd.io -y

# 启动并设置 Docker 开机自启
sudo systemctl start docker
sudo systemctl enable docker

1.2 常用 Docker 命令

查看 Docker 版本：
```
docker --version
```
拉取镜像：
```
docker pull nginx:latest
```

运行容器：

docker run -d --name my_nginx -p 8080:80 nginx

查看运行中的容器：
```
docker ps
```
停止容器：
```
docker stop my_nginx
```
删除容器：
```
docker rm my_nginx
```

构建 Docker 镜像：
创建 Dockerfile，例如：

FROM nginx:latest
COPY ./index.html /usr/share/nginx/html/index.html

然后执行：

docker build -t my_nginx_image .

1.3 Docker Compose

Docker Compose 是用于定义和运行多容器 Docker 应用的工具，可以通过 docker-compose.yml 文件来定义应用的服务、网络、卷等。

安装 Docker Compose：
```
sudo dnf install docker-compose
```

创建 docker-compose.yml 文件：

version: '3'
services:
  web:
    image: nginx
    ports:
      - "8080:80"

使用 Docker Compose 启动服务：
```
docker-compose up -d
```
查看日志：
```
docker-compose logs
```
停止服务：
```
docker-compose down
```

2. Kubernetes 实践

2.1 安装 Kubernetes

在 Linux 上安装 Kubernetes（以 AlmaLinux 为例）：

安装 Kubernetes 依赖：

sudo dnf install -y kubelet kubeadm kubectl

启动 Kubernetes 服务：
```
sudo systemctl enable --now kubelet
```
初始化 Kubernetes Master 节点：
```
sudo kubeadm init --pod-network-cidr=10.244.0.0/16
```
这将初始化 Kubernetes 集群，并返回一个命令，你需要在其他节点上使用该命令来加入集群。

配置 kubectl 访问：
运行以下命令以使 kubectl 使用当前用户的权限访问集群：

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

2.2 部署网络插件

Kubernetes 集群通常需要网络插件来提供 Pod 间的网络通信。常用的网络插件有 Flannel、Calico、Weave 等。

安装 Flannel 网络插件：

kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

2.3 Kubernetes 常用命令

查看集群节点：
```
kubectl get nodes
```
查看 Pod 状态：
```
kubectl get pods
```
创建 Deployment：
例如创建一个 Nginx 部署：
```
kubectl create deployment nginx --image=nginx
```
暴露服务：
创建一个 Service 来暴露部署的应用：
```
kubectl expose deployment nginx --port=80 --type=NodePort
```
查看暴露的服务：
```
kubectl get svc
```

删除资源：
删除部署的服务和 Pod：

kubectl delete deployment nginx
kubectl delete svc nginx

2.4 Pod 和容器的管理

查看 Pod 日志：
```
kubectl logs <pod_name>
```

执行 Pod 内命令：

kubectl exec -it <pod_name> -- /bin/bash

2.5 部署 Helm

Helm 是 Kubernetes 的包管理工具，能够简化 Kubernetes 应用的安装和管理。

安装 Helm：

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

安装应用：
```
helm install my-release nginx
```
查看已安装应用：
```
helm list
```

3. Docker 和 Kubernetes 集成实践

3.1 从 Docker 部署到 Kubernetes

创建 Docker 镜像，并将其推送到 Docker Hub 或私有 Docker 仓库。

假设已经有一个名为 myapp 的 Docker 镜像：
```
docker tag myapp <your-docker-repo>/myapp:latest
docker push <your-docker-repo>/myapp:latest
```

在 Kubernetes 中创建 Deployment，通过定义一个 yaml 文件来部署应用：

myapp-deployment.yaml：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: <your-docker-repo>/myapp:latest
        ports:
        - containerPort: 8080

部署到 Kubernetes 集群：

kubectl apply -f myapp-deployment.yaml

暴露应用：

kubectl expose deployment myapp-deployment --type=LoadBalancer --name=myapp-service

3.2 使用 Jenkins 自动化 CI/CD

Jenkins 可以与 Docker 和 Kubernetes 集成，实现自动化构建、测试和部署。

配置 Jenkins 安装 Docker 插件，以便 Jenkins 通过 Docker 来构建镜像。
创建 Jenkins pipeline，定义 CI/CD 流程，将 Docker 镜像推送到 Docker 仓库并在 Kubernetes 上自动部署。

以下是一个简化的 Jenkins Pipeline 示例：

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                script {
                    dockerImage = docker.build("myapp:${env.BUILD_ID}")
                }
            }
        }
        stage('Push') {
            steps {
                script {
                    docker.withRegistry('https://mydockerhub.com', 'my-dockerhub-credentials') {
                        dockerImage.push()
                    }
                }
            }
        }
        stage('Deploy') {
            steps {
                script {
                    sh "kubectl apply -f myapp-deployment.yaml"
                    sh "kubectl expose deployment myapp-deployment --type=LoadBalancer --name=myapp-service"
                }
            }
        }
    }
}