在Kubernetes中，如果你想要为你的容器配置特定的hosts条目，你可以使用Pod的hostAliases字段来实现。以下是一个YAML配置的例子，展示了如何为Pod添加额外的hosts条目：

apiVersion: v1
kind: Pod
metadata:
  name: custom-hosts-pod
spec:
  containers:
  - name: example
    image: nginx
  hostAliases:
  - ip: "123.45.67.89"
    hostnames:
    - "my.custom.domain"

在这个例子中，当Pod中的容器访问my.custom.domain时，它会被解析为123.45.67.89。这个功能可以用来添加临时的或者特定于Pod的hosts条目，而不需要修改节点的/etc/hosts文件。

deployment配置

在Kubernetes中，Deployment资源通常用于部署和管理Pod的副本集合。Deployment不直接支持配置hosts文件，因为这是在Pod级别进行的。但是，你可以通过定义Pod的hosts文件来实现相似的效果。

要在Kubernetes Deployment中配置hosts，你可以在Pod的spec中使用hostAliases字段来添加额外的主机名和IP地址到/etc/hosts文件中。下面是一个YAML配置的例子：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      hostAliases:
      - ip: "123.45.67.89"
        hostnames:
        - "my.custom.domain"
      containers:
      - name: my-container
        image: my-image
        ports:
        - containerPort: 80

在这个配置中，Deployment的每个Pod都将拥有一个额外的hosts条目，将my.custom.domain解析到IP 123.45.67.89。这样，Pod内的应用程序将能够使用定义的域名进行网络访问。

kubectl logs [-f] [-p] POD [-c CONTAINER]

-c, –container=””: 容器名
-f, –follow[=false]: 指定是否持续输出日志
    –interactive[=true]: 如果为true，当需要时提示用户进行输入。默认为true
    –limit-bytes=0: 输出日志的最大字节数。默认无限制
-p, –previous[=false]: 如果为true，输出pod中曾经运行过，但目前已终止的容器的日志
    –since=0: 仅返回相对时间范围，如5s、2m或3h，之内的日志。默认返回所有日志。只能同时使用since和since-time中的一种
    –since-time=””: 仅返回指定时间（RFC3339格式）之后的日志。默认返回所有日志。只能同时使用since和since-time中的一种
    –tail=-1: 要显示的最新的日志条数。默认为-1，显示所有的日志
    –timestamps[=false]: 在日志中包含时间戳

eg.：
kubectl logs ruoyiui-68b6f5f8bf-s8mk6 -n ruoyi –tail=300 -f #滚动刷新，最多显示300条
kubectl logs ipes-tree-server-75dcdc5556-nqhpg -n ipes-rd -f –limit-bytes=1000   #开始1000个字节

其他常用命令

# 获取namespace为ruoyi-dev下容器的详细信息
kubectl get pod -n ruoyi-dev -o wide
# 进入namespace为ruoyi下ruoyiui-6b86d78dfd-j4qc6容器的终端
kubectl exec -it ruoyiui-6b86d78dfd-j4qc6 /bin/bash -n ruoyi
# 应用宿主机/home/ruoyi/test.yaml文件创建或者更新
kubectl apply -f /home/ruoyi/test.yaml
# 根据宿主机/home/ruoyi/test.yaml文件创建
kubectl create -f /home/nacos/nacos-quick-start.yaml
# 删除默认namespace下名为ruoyigateway的deployment
kubectl delete deploy ruoyigateway
# 拷贝namespace为ruoyi下nacos-0容器的conf/application.properties文件到宿主机的/root下
# 注意：容器内路径只能为当前用户登陆后初始目录的相对路径
kubectl cp ruoyi/nacos-0:conf/application.properties /root/application.properties
# 查看namespace为ruoyi下nacos-1的详细信息
kubectl describe pod nacos-1 -n ruoyi
# 代理到宿主机ip和端口
kubectl proxy --port={PORT} --address='IP' --accept-hosts='^.*' &

Jenkins+harbor+nexus+docker+k8s

Jenkins执行流水线脚本命令

harbor维护管理docker镜像

nexus维护私有maven依赖

docker创建服务各个版本的docker镜像

k8s部署服务镜像

后端：

Jenkins流水线脚本

pipeline {
    agent none
    environment {
        FLAG = 'ruoyigatewaydev'
    }
    options {
        timeout(time:25, unit: 'MINUTES')
    }
    stages {
        stage('Build Package') {
            agent {
                docker {
                    image 'maven:3.6.1-jdk-8'
                    args '-v /var/lib/jenkins/repository:/repository '
                }
            }
            steps {
                git branch: 'dev',
                        credentialsId: 'gitlab_local_pwd',
                        url: 'http://git_ip:git_port/lhy/ruoyi-gateway.git'
                sh '''
                mvn -s settings.xml -Dmaven.repo.local=/repository -B clean package -DskipTests=true
                '''
            }
        }
        stage('Build image and Push') {
            agent any
            environment {
                IMAGE_TAG = sh(returnStdout: true,script: 'echo $image_tag').trim()
            }
            steps {
                sh """	
					docker build -t harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG} ./
					docker push harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
					docker image rm harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
                   """
            }
        }

        stage('Deploy') {
            agent any
            steps {
                script{
                    def remote = [:]
                    remote.name = 'kube'
                    remote.host = 'k8s_ip'
                    remote.port = 22
                    remote.allowAnyHosts = true
                    //通过withCredentials调用Jenkins凭据中已保存的凭据，credentialsId需要填写，其他保持默认即可
                    withCredentials([usernamePassword(credentialsId: 'Vm_local_pwd', passwordVariable: 'password', usernameVariable: 'userName')]) {
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    sshCommand remote: remote, command: """ 
                        if [ ! -d '/home/ruoyi/${FLAG}' ];then 
                        mkdir /home/ruoyi/${FLAG}
                        else
                        echo "文件夹已经存在"
                        fi
    				   """
                    sshPut remote: remote, from: 'k8s.yaml', into: "/home/ruoyi/${FLAG}"
                    sshCommand remote: remote, command: """ 
    					sed -i 's#${FLAG}:.*#${FLAG}:${IMAGE_TAG}#g' /home/ruoyi/${FLAG}/k8s.yaml
    					kubectl apply -f /home/ruoyi/${FLAG}/k8s.yaml
    					rm -rf /home/ruoyi/${FLAG}/k8s.yaml
    				   """
                }
            }
        }
    }
}

k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyigateway
  namespace: ruoyi-dev
  labels:
    app: ruoyigateway
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ruoyigateway
  template:
    metadata:
      name: ruoyigateway
      labels:
        app: ruoyigateway
    spec:
      containers:
        - name: ruoyigateway
          image: harbor_ip:harbor_port/public/ruoyigatewaydev:7.0
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: containerPort
              protocol: TCP
      restartPolicy: Always
      imagePullSecrets:
        - name: harbor-lhy

---
apiVersion: v1
kind: Service
metadata:
  name: ruoyigateway
  namespace: ruoyi-dev
spec:
  selector:
    app: ruoyigateway
  ports:
    - protocol: TCP
      port: port
      targetPort: targetPort
      nodePort: nodePort
  type: NodePort

DockerFile

FROM openjdk:8-jre
LABEL authors="lhyshome_pc"
ADD target/ruoyi-gateway.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

前端

Jenkins流水线脚本

pipeline {
    agent none
    environment {
        FLAG = 'ruoyiuidev'
    }
    options {
        timeout(time:25, unit: 'MINUTES')
    }
    stages {
        stage('npm') {
            agent {
                docker {
                    image 'node:14'
                    args '-u root:root --network=host'
                }
            }
            steps {
                git branch: 'dev',
                credentialsId: 'gitlab_local_pwd',
                url: 'http://git_ip:git_port/lhy/ruoyi-ui.git'
                sh """
                    npm install && npm run build:stage
                """
            }
        }
        stage('Build image and Push') {
            agent any
            environment {
                IMAGE_TAG = sh(returnStdout: true,script: 'echo $image_tag').trim()
            }
            steps {
                sh """	
					docker build -t harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG} ./
					docker push harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
					docker image rm harbor_ip:harbor_port/public/${FLAG}:${IMAGE_TAG}
                   """
            }
        }
        stage('Deploy') {
            agent any
            steps {
                script{
                    def remote = [:]
                    remote.name = 'kube'
                    remote.host = 'k8s_ip'
                    remote.port = 22
                    remote.allowAnyHosts = true
                    //通过withCredentials调用Jenkins凭据中已保存的凭据，credentialsId需要填写，其他保持默认即可
                    withCredentials([usernamePassword(credentialsId: 'Vm_local_pwd', passwordVariable: 'password', usernameVariable: 'userName')]) {
                        remote.user = "${userName}"
                        remote.password = "${password}"
                    }
                    sshCommand remote: remote, command: """ 
                        if [ ! -d '/home/ruoyi/${FLAG}' ];then 
                        mkdir /home/ruoyi/${FLAG}
                        else
                        echo "文件夹已经存在"
                        fi
    				   """
                    sshPut remote: remote, from: 'k8s.yaml', into: "/home/ruoyi/${FLAG}"
                    sshCommand remote: remote, command: """ 
    					sed -i 's#${FLAG}:.*#${FLAG}:${IMAGE_TAG}#g' /home/ruoyi/${FLAG}/k8s.yaml
    					kubectl apply -f /home/ruoyi/${FLAG}/k8s.yaml
    					rm -rf /home/ruoyi/${FLAG}/k8s.yaml
    				   """
                }
            }
        }
    }
}

k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ruoyiui
  namespace: ruoyi-dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ruoyiui
  template:
    metadata:
      labels:
        app: ruoyiui
    spec:
      containers:
        - name: ruoyiui
          image: harbor_ip:harbor_port/public/ruoyiuiprod:9.0
          ports:
            - containerPort: containerPort
---
apiVersion: v1
kind: Service
metadata:
  name: ruoyiui
  namespace: ruoyi-dev
spec:
  type: LoadBalancer
  selector:
    app: ruoyiui
  ports:
    - protocol: TCP
      port: port
      targetPort: targetPort
      nodePort: nodePort

DockerFile

FROM nginx:1.14.1
ADD ./dist /home
ADD ./nginx.conf /etc/nginx
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

nginx.conf

worker_processes  1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       80;
        server_name  localhost;

        location / {
            root   /home;
            try_files $uri $uri/ /index.html;
            index  index.html index.htm;
        }

        # 避免actuator暴露
        if ($request_uri ~ "/actuator") {
            return 403;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

1、用以下命令下载最新发行版

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

2、验证该可执行文件（可选步骤）

curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"
echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check

验证通过时，输出为：

kubectl: OK

验证失败时，sha256 将以非零值退出，并打印如下输出

kubectl: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

3、安装 kubectl

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

4、执行测试，以保障你安装的版本是最新的

kubectl version --client

或者使用如下命令来查看版本的详细信息

kubectl version --client --output=yaml

5、安装 bash-completion

yum install bash-completion
type _init_completion
echo 'source <(kubectl completion bash)' >>~/.bashrc
source ~/.bashrc

安装 kubectl convert 插件

1、用以下命令下载最新发行版

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert"

2、验证该可执行文件（可选步骤）

curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert.sha256"
echo "$(cat kubectl-convert.sha256) kubectl-convert" | sha256sum --check
#验证通过时，输出为
kubectl-convert: OK
#验证失败时，sha256 将以非零值退出，并打印输出类似于
kubectl-convert: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match

3、安装 kubectl-convert

install -o root -g root -m 0755 kubectl-convert /usr/local/bin/kubectl-convert

4、验证插件是否安装成功

kubectl convert --help 

5、安装插件后，清理安装文件

rm kubectl-convert kubectl-convert.sha256

在 Linux 系统中安装 minikube

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
install minikube-linux-amd64 /usr/local/bin/minikube
# 启动minikube --insecure-registry为harbor私有仓库地址
minikube start --force --driver=docker --image-repository='registry.cn-hangzhou.aliyuncs.com/google_containers' --registry-mirror=https://registry.docker-cn.com  --insecure-registry='IP:PORT'
# 在k8s中创建secret 连接私有harbor时授权
kubectl create secret docker-registry harbor-admin --docker-server=IP:PORT --docker-username=USERNAME --docker-password=PASSWORD --docker-email=EMAIL
# 查看secret 信息
kubectl get secret harbor-admin --output="jsonpath={.data.\.dockerconfigjson}" | base64 -d
# 在k8s中创建deployment --image为镜像地址，指向私有harbor对应镜像地址
kubectl create deployment noauth --image=IP:PORT/test/noauth:1.0  --port=9098
# 将服务公开为 NodePort
kubectl create service nodeport noauth --tcp=9098:9098 --node-port=30000

重启minikube所在的docker后 都需要重新启动minikube，将以下命令重新执行

docker restart minikube
minikube start --force --driver=docker --image-repository='registry.cn-hangzhou.aliyuncs.com/google_containers' --registry-mirror=https://registry.docker-cn.com  --insecure-registry='IP:PORT'
minikube start --memory 8192 --cpus 10 --force --driver=docker --registry-mirror=https://registry.docker-cn.com  --insecure-registry='Harbor_ip:Harbor_port'

minikube dashboard

minikube dashboard –port={port} –url

# 宿主机ip和开放的端口
kubectl proxy –port={port} –address='{ip}’ –accept-hosts=’^.*’ &

通过 http://{ip}:{port}/api/v1/namespaces/kube-system/services/http:kubernetes-dashboard:/proxy/ 访问 dashboard。