单机快速体验k8s集群的测试环境

最新推荐文章于 2024-06-05 07:15:00 发布
最新推荐文章于 2024-06-05 07:15:00 发布
阅读量1k 收藏 1
点赞数
分类专栏： kubernetes 文章标签： kubernetes
原文链接：https://github.com/easzlab/kubeasz/blob/master/docs/setup/quickStart.md
版权

快速指南

以下为快速体验k8s集群的测试、开发环境–单节点部署(aio)，国内环境下比官方的minikube方便、简单很多。

1.基础系统配置

  • 准备一台虚机配置内存2G/硬盘30G以上
  • 最小化安装Ubuntu 16.04 server或者CentOS 7 Minimal
  • 配置基础网络、更新源、SSH登录等

2.下载文件

# 下载工具脚本easzup，举例使用kubeasz版本2.0.2
export release=2.0.2
curl -C- -fLO --retry 3 https://github.com/easzlab/kubeasz/releases/download/${release}/easzup
chmod +x ./easzup
# 使用工具脚本下载
./easzup -D

上述脚本运行成功后，所有文件（kubeasz代码、二进制、离线镜像）均已整理好放入目录/etc/ansilbe

  • /etc/ansible 包含 kubeasz 版本为 ${release} 的发布代码
  • /etc/ansible/bin 包含 k8s/etcd/docker/cni 等二进制文件
  • /etc/ansible/down 包含集群安装时需要的离线容器镜像
  • /etc/ansible/down/packages 包含集群安装时需要的系统基础软件

3.配置 ssh 免密登录

ssh-keygen -t rsa -b 2048 -N '' -f ~/.ssh/id_rsa
ssh-copy-id $IP  # $IP 为所有节点地址包括自身，按照提示输入 yes 和 root 密码

4.安装集群

  • 4.1 容器化运行 kubeasz，详见文档
./easzup -S
  • 4.2 使用默认配置安装 aio 集群
docker exec -it kubeasz easzctl start-aio

5.验证安装

如果提示kubectl: command not found，退出重新ssh登录一下，环境变量生效即可

$ kubectl version                   # 验证集群版本     
$ kubectl get componentstatus       # 验证 scheduler/controller-manager/etcd等组件状态
$ kubectl get node                  # 验证节点就绪 (Ready) 状态
$ kubectl get pod --all-namespaces  # 验证集群pod状态，默认已安装网络插件、coredns、metrics-server等
$ kubectl get svc --all-namespaces  # 验证集群服务状态
  • 登录 dashboard可以查看和管理集群，更多内容请查阅dashboard文档

6.清理

以上步骤创建的K8S开发测试环境请尽情折腾，碰到错误尽量通过查看日志、上网搜索、提交issues等方式解决；当然你也可以清理集群后重新创建。

在宿主机上，按照如下步骤清理

  • 1.清理集群 docker exec -it kubeasz easzctl destroy 或 docker exec -it kubeasz ansible-playbook /etc/ansible/99.clean.yml
  • 2.清理管理节点
    • 清理运行的容器 easzup -C
    • 清理容器镜像 docker system prune -a
    • 停止docker服务 systemctl stop docker
    • 删除下载文件 rm -rf /etc/ansible /etc/docker /opt/kube
    • 删除docker文件
$ umount /var/run/docker/netns/default
$ umount /var/lib/docker/overlay
$ rm -rf /var/lib/docker /var/run/docker

上述清理脚本执行成功后，建议重启节点，以确保清理残留的虚拟网卡、路由等信息。
脚本如下

#!/bin/bash
#--------------------------------------------------
# This script is for: 
# 1. to download the scripts/binaries/images needed for installing a k8s cluster with kubeasz
# 2. to run kubeasz in a container
# @author:   gjmzj
# @usage:    ./easzup
# @repo:     https://github.com/easzlab/kubeasz
# @ref:      https://github.com/kubeasz/dockerfiles
#--------------------------------------------------

set -o nounset
set -o errexit
#set -o xtrace

# default version, can be overridden by cmd line options
export DOCKER_VER=18.09.7
export KUBEASZ_VER=2.0.2
export K8S_BIN_VER=v1.15.0
export EXT_BIN_VER=0.3.0
export SYS_PKG_VER=0.3.2

function install_docker() {
  # check if a container runtime is already installed
  systemctl status docker|grep Active|grep -q running && { echo "[WARN] docker is already running."; return 0; }
  systemctl status containerd|grep Active|grep -q running && { echo "[ERROR] containerd is running, unsupported."; exit 1; }
  
  if [[ "$REGISTRY_MIRROR" == CN ]];then
    DOCKER_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/static/stable/x86_64/docker-${DOCKER_VER}.tgz"
  else
    DOCKER_URL="https://download.docker.com/linux/static/stable/x86_64/docker-${DOCKER_VER}.tgz"
  fi

  mkdir -p /opt/kube/bin /etc/docker /etc/ansible/down
  if [[ -f "/etc/ansible/down/docker-${DOCKER_VER}.tgz" ]];then
    echo "[INFO] docker binaries already existed"
  else
    echo -e "[INFO] \033[33mdownloading docker binaries\033[0m $DOCKER_VER"
    if [[ -e /usr/bin/curl ]];then
      curl -C- -O --retry 3 "$DOCKER_URL" || { echo "[ERROR] downloading docker failed"; exit 1; }
    else
      wget -c "$DOCKER_URL" || { echo "[ERROR] downloading docker failed"; exit 1; }
    fi
    mv ./docker-${DOCKER_VER}.tgz /etc/ansible/down
  fi

  tar zxf /etc/ansible/down/docker-${DOCKER_VER}.tgz -C /etc/ansible/down && \
  mv /etc/ansible/down/docker/* /opt/kube/bin && \
  ln -sf /opt/kube/bin/docker /bin/docker 

  echo "[INFO] generate docker service file"
  cat > /etc/systemd/system/docker.service << EOF
[Unit]
Description=Docker Application Container Engine
Documentation=http://docs.docker.io
[Service]
Environment="PATH=/opt/kube/bin:/bin:/sbin:/usr/bin:/usr/sbin"
ExecStart=/opt/kube/bin/dockerd
ExecStartPost=/sbin/iptables -I FORWARD -s 0.0.0.0/0 -j ACCEPT
ExecReload=/bin/kill -s HUP \$MAINPID
Restart=on-failure
RestartSec=5
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity
Delegate=yes
KillMode=process
[Install]
WantedBy=multi-user.target
EOF

  # configuration for dockerd
  echo "[INFO] generate docker config file"
  if [[ "$REGISTRY_MIRROR" == CN ]];then
    echo "[INFO] prepare register mirror for $REGISTRY_MIRROR"
    cat > /etc/docker/daemon.json << EOF
{
  "registry-mirrors": [
    "https://dockerhub.azk8s.cn",
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF
  else
    echo "[INFO] standard config without registry mirrors"
    cat > /etc/docker/daemon.json << EOF
{
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF
  fi

  if [[ -e /etc/centos-release || -e /etc/redhat-release ]]; then
    echo "[INFO] turn off selinux in CentOS/Redhat"
    setenforce 0
    echo "SELINUX=disabled" > /etc/selinux/config
  fi

  echo "[INFO] enable and start docker"
  systemctl enable docker
  systemctl daemon-reload && systemctl restart docker && sleep 8
}

function get_kubeasz() {
  # check if kubeasz already existed
  [[ -d "/etc/ansible/roles/kube-node" ]] && { echo "[WARN] kubeasz already existed"; return 0; }

  echo -e "[INFO] \033[33mdownloading kubeasz\033[0m $KUBEASZ_VER"
  echo "[INFO] run a temporary container"
  docker run -d --name temp_easz easzlab/kubeasz:${KUBEASZ_VER} || { echo "[ERROR] download failed."; exit 1; }

  [[ -f "/etc/ansible/down/docker-${DOCKER_VER}.tgz" ]] && mv "/etc/ansible/down/docker-${DOCKER_VER}.tgz" /tmp

  rm -rf /etc/ansible && \
  echo "[INFO] cp kubeasz code from the temporary container" && \
  docker cp temp_easz:/etc/ansible /etc/ansible && \
  echo "[INFO] stop&remove temporary container" && \
  docker rm -f temp_easz

 [[ -f "/tmp/docker-${DOCKER_VER}.tgz" ]] && mv "/tmp/docker-${DOCKER_VER}.tgz" /etc/ansible/down
 return 0
}

function get_k8s_bin() {
  [[ -f "/etc/ansible/bin/kubelet" ]] && { echo "[WARN] kubernetes binaries existed"; return 0; }
  
  echo -e "[INFO] \033[33mdownloading kubernetes\033[0m $K8S_BIN_VER binaries"
  docker pull easzlab/kubeasz-k8s-bin:${K8S_BIN_VER} && \
  echo "[INFO] run a temporary container" && \
  docker run -d --name temp_k8s_bin easzlab/kubeasz-k8s-bin:${K8S_BIN_VER} && \
  echo "[INFO] cp k8s binaries" && \
  docker cp temp_k8s_bin:/k8s /k8s_bin_tmp && \
  mv /k8s_bin_tmp/* /etc/ansible/bin && \
  echo "[INFO] stop&remove temporary container" && \
  docker rm -f temp_k8s_bin && \
  rm -rf /k8s_bin_tmp
}

function get_ext_bin() {
  [[ -f "/etc/ansible/bin/etcdctl" ]] && { echo "[WARN] extral binaries existed"; return 0; }

  echo -e "[INFO] \033[33mdownloading extral binaries\033[0m kubeasz-ext-bin:$EXT_BIN_VER"
  docker pull easzlab/kubeasz-ext-bin:${EXT_BIN_VER} && \
  echo "[INFO] run a temporary container" && \
  docker run -d --name temp_ext_bin easzlab/kubeasz-ext-bin:${EXT_BIN_VER} && \
  echo "[INFO] cp extral binaries" && \
  docker cp temp_ext_bin:/extra /extra_bin_tmp && \
  mv /extra_bin_tmp/* /etc/ansible/bin && \
  echo "[INFO] stop&remove temporary container" && \
  docker rm -f temp_ext_bin && \
  rm -rf /extra_bin_tmp
}

function get_sys_pkg() {
  [[ -f "/etc/ansible/down/packages/chrony_xenial.tar.gz" ]] && { echo "[WARN] system packages existed"; return 0; }

  echo -e "[INFO] \033[33mdownloading system packages\033[0m kubeasz-sys-pkg:$SYS_PKG_VER"
  docker pull easzlab/kubeasz-sys-pkg:${SYS_PKG_VER} && \
  echo "[INFO] run a temporary container" && \
  docker run -d --name temp_sys_pkg easzlab/kubeasz-sys-pkg:${SYS_PKG_VER} && \
  echo "[INFO] cp system packages" && \
  docker cp temp_sys_pkg:/packages /etc/ansible/down && \
  echo "[INFO] stop&remove temporary container" && \
  docker rm -f temp_sys_pkg
}

function get_offline_image() {
  # images needed by k8s cluster
  calicoVer=v3.4.4
  corednsVer=1.5.0
  dashboardVer=v1.10.1
  flannelVer=v0.11.0-amd64
  heapsterVer=v1.5.4
  metricsVer=v0.3.3
  pauseVer=3.1
  traefikVer=v1.7.12

  imageDir=/etc/ansible/down
  [[ -d "$imageDir" ]] || { echo "[ERROR] $imageDir not existed!"; exit 1; }
  
  echo -e "[INFO] \033[33mdownloading offline images\033[0m"

  if [[ ! -f "$imageDir/calico_$calicoVer.tar" ]];then
    docker pull calico/cni:${calicoVer} && \
    docker pull calico/kube-controllers:${calicoVer} && \
    docker pull calico/node:${calicoVer} && \
    docker save -o ${imageDir}/calico_${calicoVer}.tar calico/cni:${calicoVer} calico/kube-controllers:${calicoVer} calico/node:${calicoVer}
  fi
  if [[ ! -f "$imageDir/coredns_$corednsVer.tar" ]];then
    docker pull coredns/coredns:${corednsVer} && \
    docker save -o ${imageDir}/coredns_${corednsVer}.tar coredns/coredns:${corednsVer}
  fi
  if [[ ! -f "$imageDir/dashboard_$dashboardVer.tar" ]];then
    docker pull mirrorgooglecontainers/kubernetes-dashboard-amd64:${dashboardVer} && \
    docker save -o ${imageDir}/dashboard_${dashboardVer}.tar mirrorgooglecontainers/kubernetes-dashboard-amd64:${dashboardVer}
  fi
  if [[ ! -f "$imageDir/flannel_$flannelVer.tar" ]];then
    docker pull easzlab/flannel:${flannelVer} && \
    docker save -o ${imageDir}/flannel_${flannelVer}.tar easzlab/flannel:${flannelVer}
  fi
  if [[ ! -f "$imageDir/heapster_$heapsterVer.tar" ]];then
    docker pull mirrorgooglecontainers/heapster-amd64:${heapsterVer} && \
    docker save -o ${imageDir}/heapster_${heapsterVer}.tar mirrorgooglecontainers/heapster-amd64:${heapsterVer}
  fi
  if [[ ! -f "$imageDir/metrics-server_$metricsVer.tar" ]];then
    docker pull mirrorgooglecontainers/metrics-server-amd64:${metricsVer} && \
    docker save -o ${imageDir}/metrics-server_${metricsVer}.tar mirrorgooglecontainers/metrics-server-amd64:${metricsVer}
  fi
  if [[ ! -f "$imageDir/pause_$pauseVer.tar" ]];then
    docker pull mirrorgooglecontainers/pause-amd64:${pauseVer} && \
    docker save -o ${imageDir}/pause_${pauseVer}.tar mirrorgooglecontainers/pause-amd64:${pauseVer}
  fi
  if [[ ! -f "$imageDir/traefik_$traefikVer.tar" ]];then
    docker pull traefik:${traefikVer} && \
    docker save -o ${imageDir}/traefik_${traefikVer}.tar traefik:${traefikVer}
  fi
  if [[ ! -f "$imageDir/kubeasz_$KUBEASZ_VER.tar" ]];then
    docker pull easzlab/kubeasz:${KUBEASZ_VER} && \
    docker save -o ${imageDir}/kubeasz_${KUBEASZ_VER}.tar easzlab/kubeasz:${KUBEASZ_VER}
  fi
}

function download_all() {
  install_docker && \
  get_kubeasz && \
  get_k8s_bin && \
  get_ext_bin && \
  get_sys_pkg && \
  get_offline_image
}

function start_kubeasz_docker() {
  [[ -d "/etc/ansible/roles/kube-node" ]] || { echo "[ERROR] not initialized. try 'easzup -D' first."; exit 1; }

  # get host's IP
  host_if=$(ip route|grep default|cut -d' ' -f5)
  host_ip=$(ip a|grep "$host_if$"|awk '{print $2}'|cut -d'/' -f1)
  echo "[INFO] get host IP: $host_ip"

  # allow ssh login using key locally
  if [[ ! -e /root/.ssh/id_rsa ]]; then
    echo "[INFO] generate ssh key pair"
    ssh-keygen -t rsa -b 2048 -N '' -f /root/.ssh/id_rsa > /dev/null
    cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
    ssh-keyscan -t ecdsa -H "$host_ip" >> /root/.ssh/known_hosts
  fi

  # create a link '/usr/bin/python' in Ubuntu1604
  if [[ ! -e /usr/bin/python && -e /etc/debian_version ]]; then
    echo "[INFO] create a soft link '/usr/bin/python'"
    ln -s /usr/bin/python3 /usr/bin/python
  fi

  # 
  docker load -i /etc/ansible/down/kubeasz_${KUBEASZ_VER}.tar

  # run kubeasz docker container
  echo "[INFO] run kubeasz in a container"
  docker run --detach \
      --name kubeasz \
      --restart always \
      --env HOST_IP="$host_ip" \
      --volume /etc/ansible:/etc/ansible \
      --volume /root/.kube:/root/.kube \
      --volume /root/.ssh/id_rsa:/root/.ssh/id_rsa:ro \
      --volume /root/.ssh/id_rsa.pub:/root/.ssh/id_rsa.pub:ro \
      --volume /root/.ssh/known_hosts:/root/.ssh/known_hosts:ro \
      easzlab/kubeasz:${KUBEASZ_VER} sleep 36000
}

function clean_container() {
 echo "[INFO] clean all running containers"
 docker ps -a|awk 'NR>1{print $1}'|xargs docker rm -f 
} 

function usage() {
  cat <<EOF
Usage: easzup [options] [args]
  option: -{DdekSz}
    -C         stop&clean all local containers
    -D         download all into /etc/ansible
    -S         start kubeasz in a container
    -d <ver>   set docker-ce version, default "$DOCKER_VER"
    -e <ver>   set kubeasz-ext-bin version, default "$EXT_BIN_VER"
    -k <ver>   set kubeasz-k8s-bin version, default "$K8S_BIN_VER"
    -m <str>   set docker registry mirrors, default "CN"(used in Mainland,China)
    -p <ver>   set kubeasz-sys-pkg version, default "$SYS_PKG_VER"
    -z <ver>   set kubeasz version, default "$KUBEASZ_VER"
  
see more at https://github.com/kubeasz/dockerfiles
EOF
} 

### Main Lines ##################################################
function main() {
  # check if use bash shell
  readlink /proc/$$/exe|grep -q "dash" && { echo "[ERROR] you should use bash shell, not sh"; exit 1; }
  # check if use with root
  [[ "$EUID" -ne 0 ]] && { echo "[ERROR] you should run this script as root"; exit 1; }
  
  [[ "$#" -eq 0 ]] && { usage >&2; exit 1; }
  
  export REGISTRY_MIRROR="CN"
  ACTION=""
  while getopts "CDSd:e:k:m:p:z:" OPTION; do
      case "$OPTION" in
        C)
          ACTION="clean_container"
          ;;
        D)
          ACTION="download_all"
          ;;
        S)
          ACTION="start_kubeasz_docker"
          ;;
        d)
          export DOCKER_VER="$OPTARG"
          ;;
        e)
          export EXT_BIN_VER="$OPTARG"
          ;;
        k)
          export K8S_BIN_VER="$OPTARG"
          ;;
        m)
          export REGISTRY_MIRROR="$OPTARG"
          ;;
        p)
          export SYS_PKG_VER="$OPTARG"
          ;;
        z)
          export KUBEASZ_VER="$OPTARG"
          ;;
        ?)
          usage
          exit 1
          ;;
      esac
  done
  
  [[ "$ACTION" == "" ]] && { echo "[ERROR] illegal option"; usage; exit 1; }
  
  # excute cmd "$ACTION" 
  echo -e "[INFO] \033[33mAction begin\033[0m : $ACTION"
  ${ACTION} || { echo -e "[ERROR] \033[31mAction failed\033[0m : $ACTION"; return 1; }
  echo -e "[INFO] \033[32mAction successed\033[0m : $ACTION"
}

main "$@"
菩提笑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
k8s集群环境搭建资源
10-27
k8s集群环境搭建资源
一键安装k8s脚本
清雨小竹
05-09 1931
4.安装完毕可以在master节点上查看状态：kubectl get nodes。1.master节点安装脚本：install_k8s_master.sh。2.node节点安装脚本：install_k8s_node.sh。3.安装完成master节点后会提示加入节点的命令类似这样。安装过程中会有根据提示要求键盘输入。在各个node节点上执行命令即可。
一文教你在k8s中部署单机版kafka（保姆级教程）
最新发布
博客虽小，世界尽在其中
06-05 1685
本文详细阐述了在Kubernetes（k8s）集群中部署单机版Apache Kafka的步骤和注意事项。Kafka是一个分布式流处理平台，广泛应用于大数据处理、实时日志分析、事件驱动微服务等场景。在k8s中部署Kafka可以充分利用其容器编排和自动化管理的优势，提高Kafka集群的可用性和可伸缩性。 文章首先介绍了Kafka的基本概念，包括主题（Topic）、分区（Partition）、生产者（Producer）、消费者（Consumer）等，并解释了为什么选择k8s作为Kafka的部署环境。接着，文章详细
一键安装k8s ！！！
FK_凡柯的博客
07-06 557
一键安装k8s ！！！ 傻瓜式安装
k8s 一键安装Kubernetes集群
u014644574的博客
10-30 1228
Kubernetes - 一键安装Kubernetes集群
k8s-使用kube-install一键部署(亲测超详细)
program哲学
12-11 3545
详细介绍k8s部署环境介绍及一键安装脚本kube-install, 支持高度可用的多个kubernetes集群可以在二进制模式下一键离线安装，也可以计划安装、添加kubernets节点、删除kubernete节点、销毁kubernetesmaster、重建kubernetes-master和卸载集群
kubeasz一键部署harbor、containerd运行时、高可用k8s（1.26.x）集群-Day 02
qq_42515722的博客
05-04 4470
kubeasz一键部署k8s1.26.1
K8S—集群部署
m0_63674789的博客
05-29 8679
K8S概述： K8s是容器集群管理系统，是一个开源的平台，可以实现容器集群的自动化部署、自动扩展容维护等功能，k8s的原名是kubernetes。
快速部署k8s单机版
01-07
k8s单机版，主要目的是快速部署，供我们试验和学习k8s之用。 我们这里部署的kubernetes 1.13版本 一，关闭selinux和firewalld # setenforce 0 # systemctl stop firewalld # sed -i 's/^SELINUX=enforcing$/SELINUX...
使用Microk8s快速创建k8s集群
01-26
在本篇文章中，我们将学习如何使用Microk8s快速创建k8s集群，Microk8s是一个轻量级的Kubernetes发行版，非常适合开发、测试和学习环境。下面是详细的步骤和知识点： 1. 准备环境 在开始之前，我们需要关闭防火墙，...
Kind工具-快速构建K8s集群
01-25
1、Kind工具， 2、快速构建K8s集群， 3、mac可用。
k8s-auto-kubernetes/k8s一键安装
12-15
kubernetes/k8s自动安装程序，版本对应:v1.18.2，linux环境 使用kubeadm安装，改程序若环境不符合要求，是不能一键安装的，需按照程序指示分布安装，该程序是为了搭建测试环境时，简化繁琐的配置时所用，不能用作生产使用，造成一切后果，本人不承担任何责任；此集成是为了让小伙伴们学习了解k8s运作机理时，可快速部署，省去多步手动配置所写； 程序逐渐完善中有疑问，欢迎私信我解决... 程序安装会进行环境检查，若不满足要求则会提示更改后方能继续执行（具体见文件说明）；
kubeadm、k8s集群环境简易搭建
10-01
unbuntu16.04环境，kubeadm搭建k8s集群脚本 参考文档如下 1.https://time.geekbang.org/column/article/39724 2.https://my.oschina.net/u/2306127/blog/1843053 3....
k8s学习-k8s初识、Centos下集群安装与一键离线安装
关注网络安全、云原生安全
04-30 2723
K8s概念 Namespace:命令空间，相当于把一个集群虚拟成多个集群，部分资源具有隔离性Pod:K8s最小单元，可以简单理解为一个、多个或一组容器的集合。 Deployment:无状态应用控制器，可以随意重启的服务等，例如，可放置HTML5文件 StatefulSet:有状态应用控制器，提供固定标识符，可放置redis集群等 DaemonSet:守护进程控制器 Service:逻辑上的一组Pod，用于集群服务通信 Ingress：集群服务入口，通过域名发布服务，代替经常变化的ip ConfigMap：K
Kubernetes - 一键安装部署 K8S（附：Kubernetes Dashboard）
牧码的博客
10-23 1805
Kubernetes - 一键安装部署 K8S（附：Kubernetes Dashboard）
Kubernetes（k8s）超详细的安装步骤
热门推荐
wuds_158的博客
07-06 1万+
验证：kubectl get node。
KubeSphere一键安装部署K8S集群（单master节点）-亲测过
qq_759035366的博客
10-22 1047
【代码】KubeSphere一键安装部署K8S集群（单master节点）-亲测过。
kubesphere一键部署k8s
weixin_44770684的博客
11-06 2417
一键部署k8s kubekey kubesphere 使用 kubekey一键部署k8s 国内源一键部署k8s Linux centos yum源
快速部署一个k8s集群
孤独，平庸，落魄
03-02 1351
部署一套单Master的K8s集群 kubeadm方式 文章目录部署一套单Master的K8s集群1、前置知识点1.2 准备环境1.3 操作系统初始化配置【所有节点】2. 安装Docker/kubeadm/kubelet【所有节点】。2.1 安装Docker。2.2 添加阿里云YUM软件源。2.3 安装kubeadm，kubelet和kubectl.3. 部署Kubernetes Master.4. 加入Kubernetes Node5. 部署容器网络（CNI）6. 测试kubernetes集群7. 部署
2021年12月：快速搭建K8S 1.23.0集群环境指南
本文档详细介绍了如何在2021年12月11日的最新环境中搭建Kubernetes (K8s) 集群，主要涉及以下几个关键步骤： 1. **准备环境**： - 在开始前，确保已经在VMware中设置了至少3个虚拟机，包括master节点、worker节点1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值