为k8s集群手动添加节点脚本

k8s手动添加节点脚本

#!/usr/bin/env bash

################################################
#
# KUBE_VERSION     the expected kubernetes version
# eg.  ./attachKubernetesNode
#           --docker-version 17.06.2-ce-1 \
#           --token 264db1.30bcc2b89969a4ca \
#           --endpoint 192.168.0.80:6443
#           --cluster-dns 172.19.0.10
################################################

set -e -x

PKG=pkg

export CLOUD_TYPE=private
export openapi="http://cs-intranet.inter.env17e.shuguang.com"
export GPU_FOUNDED=0
export PKG_FILE_SERVER="https://chest-biz.acs.inter.env17e.shuguang.com:8080/static/k8s/"
export KUBE_REPO_PREFIX="registry.acs.intra.env17e.shuguang.com/acs"
export INTERNET_DOMAIN="inter.env17e.shuguang.com"
export SLB_ENDPOINT="http://slb-vpc.inter.env17e.shuguang.com"
export ECS_ENDPOINT="http://ecs-internal.inter.env17e.shuguang.com"
export INSECURE_REGISTRY="cr.registry.inter.env17e.shuguang.com"

public::common::log() {
        echo $(date +"[%Y%m%d %H:%M:%S]: ") $1
}

public::cert::addCA()
{
    set +e
    curl -k --retry 4 --retry-delay 5 -sSL $PKG_FILE_SERVER/$CLOUD_TYPE/static.pem>static.pem
    if [ "$?" != 0 ];then
        echo "failed to download root ca from static file server."; set -e
        retrun
    fi
    set -e
    dir=/etc/pki/ca-trust/source/anchors/
    mkdir -p $dir ; mv static.pem $dir/static.pem
    update-ca-trust
}

public::common::arch() {
    export OS_ARCH=amd64
    case `uname -m` in
        "sw_64" )
            export OS_ARCH=sw64
            ;;
        "x86_64")
            export OS_ARCH=amd64
            ;;
        "arm64")
            export OS_ARCH=arm64
            ;;
        *)
            echo "unknown arch `uname -a`, default to amd64 "
            ;;
    esac
        OS_TYPE=linux
}
public::common::arch

public::common::region()
{
    if [ "$CLOUD_TYPE" != "agility" ];then
        region=$(curl --retry 5  -sSL http://100.100.100.200/latest/meta-data/region-id)
        if [ "" == "$region" ];then
            kube::common::log "can not get regionid and instanceid! \
                curl --retry 5 -sSL http://100.100.100.200/latest/meta-data/region-id" && exit 256
                fi
                export REGION=$region
        else
                public::common::log "Do nothing for aglity"
        fi
}

public::common::os_env() {
        ubu=$(cat /etc/issue | grep "Ubuntu 16.04" | wc -l)
        cet=$(cat /etc/centos-release | grep "CentOS" | wc -l)
        suse=$(cat /etc/os-release | grep "SUSE" | wc -l)
        redhat=$(cat /etc/redhat-release | grep "Red Hat" | wc -l)
        alios=$(cat /etc/redhat-release | grep "Alibaba" | wc -l)
        if [ "$ubu" == "1" ]; then
                export OS="Ubuntu"
        elif [ "$cet" == "1" ]; then
                export OS="CentOS"
        elif [ "$suse" == "1" ]; then
                export OS="SUSE"
        elif [ "$redhat" == "1" ]; then
                export OS="RedHat"
        elif [ "$alios" == "1" ]; then
                export OS="AliOS"
        else
                public::common::log "unkown os...   exit"
                exit 1
        fi
}

## public::common::prepare_package
#  New Package Name Pattern to support multi-os & multi-arch
#       OS_TYPE:   linux[CentOS(RPM)]
#       Arch: amd64 sw64 arm64
#  $PKG_FILE_SERVER/$CLOUD_TYPE/pkg/$PKG_TYPE/${PKG_TYPE}-${PKG_VERSION}-${OS_TYPE}-${OS_ARCH}.tar.gz
public::common::prepare_package() {
        PKG_TYPE=$1
        PKG_VERSION=$2
        if [[ "$PKG_VERSION" != "1.11.5" ]];
    then
        MULTI_OS=-${OS_TYPE}-${OS_ARCH}
    fi
        pkg=${PKG_TYPE}-${PKG_VERSION}${MULTI_OS}.tar.gz
        if [[ ! -f ${pkg} ]]; then
                if [[ -z ${PKG_FILE_SERVER} ]]; then
                        public::common::log "local file ${pkg} does not exist, And PKG_FILE_SERVER is not config"
                        public::common::log "installer does not known where to download installer binary package without PKG_FILE_SERVER env been set. Error: exit"
                        exit 1
                fi
                public::common::log "local file ${pkg} does not exist, trying to download from [$PKG_FILE_SERVER]"
                curl -k --retry 4 --retry-delay 5 -sSL \
                    ${PKG_FILE_SERVER}/${CLOUD_TYPE}/pkg/${PKG_TYPE}/${pkg} \
                        >${pkg} || (public::common::log "download failed with 4 retry,exit 1" && exit 1)
        fi
        tar -xvf ${pkg} || (public::common::log "untar ${pkg} failed!, exit" && exit 1)
}

public::common::nodeid()
{
    if [ "$CLOUD_TYPE" != "agility" ];then
        region=$(curl --retry 5  -sSL http://100.100.100.200/latest/meta-data/region-id)
        insid=$(curl --retry 5  -sSL http://100.100.100.200/latest/meta-data/instance-id)
        if [ "" == "$region" -o "" == "$insid" ];then
            kube::common::log "can not get regionid and instanceid! \
            curl --retry 5 -sSL http://100.100.100.200/latest/meta-data/region-id" && exit 256
                fi
                export NODE_ID=$region.$insid
        else
                public::common::log "Do nothing for aglity"
        fi
}

function version_gt() { test "$(echo "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1"; }

function retry() {
        local n=0
        local try=$1
        local cmd="${@:2}"
        [[ $# -le 1 ]] && {
                echo "Usage $0 <retry_number> <Command>"
        }
        set +e
        until
                [[ $n -ge $try ]]
        do
                $cmd && break || {
                        echo "Command Fail.."
                        ((n++))
                        echo "retry $n :: [$cmd]"
                        sleep 2
                }
        done
        set -e
}

public::common::install_package() {

        public::docker::install

        public::common::prepare_package "kubernetes" $KUBE_VERSION
        public::common::prepare_package "addons" $KUBE_VERSION || true

    local registry_domain=`echo $KUBE_REPO_PREFIX|awk -F "/" '{print $1}'`
    sed -i "s#registry.cn-hangzhou.aliyuncs.com#$registry_domain#g" pkg/kubernetes/$KUBE_VERSION/module/*

    public::common::apply_sysctls
    # Install crictl
        CRI_CRL="pkg/kubernetes/$KUBE_VERSION/rpm/crictl"
        if [ -f "$CRI_CRL" ];then
        chmod +x "$CRI_CRL"
        mv "$CRI_CRL" /usr/bin/crictl
        fi
    if [ "$OS" == "CentOS" ] || [ "$OS" == "RedHat" ] || [ "$OS" == "AliOS" ];then
        dir=pkg/kubernetes/$KUBE_VERSION/rpm

        # Install nfs client and socat
        rpm --replacepkgs -ivh `ls $dir | xargs -I '{}' echo -n "$dir/{} "`
    elif [ "$OS" == "Ubuntu" ];then
        dir=pkg/kubernetes/$KUBE_VERSION/debain
        dpkg -i `ls $dir | xargs -I '{}' echo -n "$dir/{} "`
    elif [ "$OS" == "SUSE" ];then
        dir=pkg/kubernetes/$KUBE_VERSION/rpm
        zypper --no-gpg-checks install -y `ls $dir | xargs -I '{}' echo -n "$dir/{} "`
    fi

        sed -i "s#--cluster-dns=10.96.0.10 --cluster-domain=cluster.local#--cluster-dns=$CLUSTER_DNS \
    --pod-infra-container-image=$KUBE_REPO_PREFIX/pause-amd64:3.0 \
    --enable-controller-attach-detach=false \
    --cluster-domain=cluster.local --cloud-provider=external \
    --hostname-override=$NODE_ID --provider-id=$NODE_ID#g" \
                /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
        if docker info | grep 'Cgroup Driver' | grep cgroupfs; then
                sed -i -e 's/cgroup-driver=systemd/cgroup-driver=cgroupfs/g' \
                        /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
        fi

        # set node resource reserve when available memory > 3.5G
        if [[ $(cat /proc/meminfo | awk '/MemTotal/ {print $2}') -gt $((1024 * 512 * 7)) ]]; then
                sed -i -e "s/--cgroup-driver=/--system-reserved=memory=300Mi \
                --kube-reserved=memory=400Mi \
                --eviction-hard=imagefs.available<15%,memory.available<300Mi,nodefs.available<10%,nodefs.inodesFree<5% --cgroup-driver=/g" \
                        /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
        fi

        systemctl daemon-reload
        systemctl enable kubelet.service
        systemctl start kubelet.service
}

public::common::apply_sysctls() {
        declare -A sysctls_map=(
                ["vm.max_map_count"]="262144"
                ["kernel.softlockup_panic"]="1"
                ["kernel.softlockup_all_cpu_backtrace"]="1"
                ["net.core.somaxconn"]="32768"
                ["net.core.rmem_max"]="16777216"
                ["net.core.wmem_max"]="16777216"
                ["net.ipv4.tcp_wmem"]="4096 12582912 16777216"
                ["net.ipv4.tcp_rmem"]="4096 12582912 16777216"
                ["net.ipv4.tcp_max_syn_backlog"]="8096"
                ["net.ipv4.tcp_slow_start_after_idle"]="0"
                ["net.core.netdev_max_backlog"]="16384"
                ["fs.file-max"]="2097152"
                ["fs.inotify.max_user_instances"]="8192"
                ["fs.inotify.max_user_watches"]="524288"
                ["fs.inotify.max_queued_events"]="16384"
                ["net.ipv4.ip_forward"]="1"
                ["net.bridge.bridge-nf-call-iptables"]="1"
                ["fs.may_detach_mounts"]="1"
        )

        if [ ! -f /etc/sysctl.d/99-k8s.conf ]; then
                mkdir -p /etc/sysctl.d/ && touch /etc/sysctl.d/99-k8s.conf
                echo "#sysctls for k8s node config" >/etc/sysctl.d/99-k8s.conf
        fi
        for key in ${!sysctls_map[@]}; do
                sysctl_path="/proc/sys/"${key//./\/}
                if [ -f ${sysctl_path} ]; then
                        sed -i "/${key}/ d" /etc/sysctl.d/99-k8s.conf
                        echo "${key}=${sysctls_map[${key}]}" >>/etc/sysctl.d/99-k8s.conf
                fi
        done
        sysctl --system || true
}

public::docker::install() {

    if [ "$CLOUD_TYPE" == "private" ];then
        echo "add tianji root ca ."
        # try add root ca
        public::cert::addCA
    fi

        set +e
        docker version >/dev/null 2>&1
        i=$?
        set -e
        v=$(docker version | grep Version | awk '{gsub(/-/, ".");print $2}' | uniq)
        if [ $i -eq 0 ]; then
                if [[ "$DOCKER_VERSION" == "$v" ]]; then
                        public::common::log "docker has been installed , return. $DOCKER_VERSION"
                        return
                fi
        fi
        public::common::prepare_package "docker" $DOCKER_VERSION
        if [ "$OS" == "CentOS" ] || [ "$OS" == "RedHat" ] || [ "$OS" == "AliOS" ]; then
                if [ "$(rpm -qa docker-engine-selinux | wc -l)" == "1" ]; then
                        yum erase -y docker-engine-selinux
                fi
                if [ "$(rpm -qa docker-engine | wc -l)" == "1" ]; then
                        yum erase -y docker-engine
                fi
                if [ "$(rpm -qa docker-ce | wc -l)" == "1" ]; then
                        yum erase -y docker-ce
                fi
                if [ "$(rpm -qa container-selinux | wc -l)" == "1" ]; then
                        yum erase -y container-selinux
                fi

                if [ "$(rpm -qa docker-ee | wc -l)" == "1" ]; then
                        yum erase -y docker-ee
                fi

                local pkg=pkg/docker/$DOCKER_VERSION/rpm/
                rpm --replacepkgs -Uvh --nodeps --force `ls $pkg |xargs -I '{}' echo -n "$pkg{} "`
        elif [ "$OS" == "Ubuntu" ]; then
                if [ "$need_reinstall" == "true" ]; then
                        if [ "$(echo $v | grep ee | wc -l)" == "1" ]; then
                                apt purge -y docker-ee docker-ee-selinux
                        elif [ "$(echo $v | grep ce | wc -l)" == "1" ]; then
                                apt purge -y docker-ce docker-ce-selinux container-selinux
                        else
                                apt purge -y docker-engine
                        fi
                fi
                dir=pkg/docker/$DOCKER_VERSION/debain
                dpkg -i $(ls $dir | xargs -I '{}' echo -n "$dir/{} ")
        elif [ "$OS" == "SUSE" ]; then
                if [ "$(rpm -qa docker-engine-selinux | wc -l)" == "1" ]; then
                        zypper rm -y docker-engine-selinux
                fi
                if [ "$(rpm -qa docker-engine | wc -l)" == "1" ]; then
                        zypper rm -y docker-engine
                fi
                if [ "$(rpm -qa docker-ce | wc -l)" == "1" ]; then
                        zypper rm -y docker-ce
                fi
                if [ "$(rpm -qa container-selinux | wc -l)" == "1" ]; then
                        zypper rm -y container-selinux
                fi

                if [ "$(rpm -qa docker-ee | wc -l)" == "1" ]; then
                        zypper rm -y docker-ee
                fi
                local pkg=pkg/docker/$KUBE_VERSION/rpm/
                zypper --no-gpg-checks install -y $(ls $pkg | xargs -I '{}' echo -n "$pkg{} ")
        else
                public::common::log "install docker with [unsupported OS version] error!"
                exit 1
        fi
        public::docker::config
}

public::docker::daemon_config_json() {
        if public::common::region4mirror "$REGION"; then
                local mirror="\"https://pqbap4ya.mirror.aliyuncs.com\""
        fi

        if [ "$DOCKER_VERSION" != "17.06.2.ce" ]; then
                local use_systemd_cgroup='native.cgroupdriver=systemd'
        fi

        if [ ! -d /etc/docker/ ]; then
                mkdir -p /etc/docker/
        fi

        if [ "1" == "$GPU_FOUNDED" ]; then
                cat >/etc/docker/daemon.json <<-EOF
{
    "default-runtime": "nvidia",
    "runtimes": {
        "nvidia": {
            "path": "/usr/bin/nvidia-container-runtime",
            "runtimeArgs": []
        }
    },
    "exec-opts": ["$use_systemd_cgroup"],
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "100m",
        "max-file": "10"
    },
    "bip": "169.254.123.1/24",
    "oom-score-adjust": -1000,
    "registry-mirrors": [$mirror],
    "insecure-registries" : ["`echo $KUBE_REPO_PREFIX|awk -F "/" '{print $1}'`","`echo $INSECURE_REGISTRY`", "`echo $INSECURE_REGISTRY|awk -F ":" '{print $1}'`"],
    "storage-driver": "overlay2",
    "storage-opts":["overlay2.override_kernel_check=true"],
    "live-restore": true
}
EOF
        else
                cat >/etc/docker/daemon.json <<-EOF
{
    "exec-opts": ["$use_systemd_cgroup"],
    "log-driver": "json-file",
    "log-opts": {
        "max-size": "100m",
        "max-file": "10"
    },
    "bip": "169.254.123.1/24",
    "oom-score-adjust": -1000,
    "registry-mirrors": [$mirror],
    "insecure-registries" : ["`echo $KUBE_REPO_PREFIX|awk -F "/" '{print $1}'`","`echo $INSECURE_REGISTRY`", "`echo $INSECURE_REGISTRY|awk -F ":" '{print $1}'`"],
    "storage-driver": "overlay2",
    "storage-opts":["overlay2.override_kernel_check=true"],
    "live-restore": true
}
EOF
        fi
}

public::docker::config() {
        iptables -P FORWARD ACCEPT
        if [ ! -f /etc/systemd/system/docker.service ]; then
                cp /lib/systemd/system/docker.service /etc/systemd/system/docker.service
        fi
        if [ "$OS" == "CentOS" ] || [ "$OS" == "RedHat" ] || [ "$OS" == "AliOS" ]; then
                sed -i -e 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
                sed -i 's#LimitNOFILE=infinity#LimitNOFILE=1048576#g' /etc/systemd/system/docker.service
                if systemctl cat containerd &> /dev/null; then
                        sed -i 's#^After=network-online.target firewalld.service$#After=network-online.target firewalld.service containerd.service#g' \
                        /etc/systemd/system/docker.service
                fi
        fi

        public::docker::daemon_config_json

        sed -i "/ExecStart=/a\ExecStartPost=/usr/sbin/iptables -P FORWARD ACCEPT" /etc/systemd/system/docker.service

        systemctl daemon-reload
        systemctl enable docker.service
        # workaround for https://github.com/docker/for-linux/issues/556
        if systemctl cat containerd &> /dev/null; then
                systemctl start containerd
                retry 3 ctr --timeout 1s --connect-timeout 1s version
        fi
        systemctl restart docker.service
}

public::common::region4mirror() {
        local region=$1

        # set mirror for false, if the current region is not China Mainland
        if [[ $region == "cn-hongkong" ]] ||
                [[ $region != *"cn-"* ]]; then
                false
        else
                true
        fi
}

public::main::node_up()
{
    public::main::clean_cni

        public::common::nodeid

        public::common::install_package

        if [ $AUTO_FDISK != "" ]; then
            if [ "$DISK_DEVICE" == "" ];then
                # use default device as before
                DISK_DEVICE="/dev/xvdb"
            if [ -b "/dev/vdb" ]; then
                DISK_DEVICE="/dev/vdb"
            fi
                echo "disk device must be specified for auto mount docker disk. --disk-device=/dev/vdb"
            fi
                public::main::mount_disk "$DISK_DEVICE"
        fi

        if [[ $KUBE_VERSION == *"1.8"* ]]; then
                echo "Not support GPU yet for $KUBE_VERSION!"
        else
                public::main::nvidia_gpu
        fi

        if [ $FROM_ESS != "" ]; then
                public::main::attach_label
        fi

        discover="--discovery-token-unsafe-skip-ca-verification"

        kubeadm join --node-name "$NODE_ID" --token $TOKEN $APISERVER_LB $discover

        retry 30 grep cluster /etc/kubernetes/kubelet.conf
        cp /etc/kubernetes/kubelet.conf /etc/kubernetes/kubelet.old

        if [[ "$APISERVER_LB" != "1.1.1.1" ]]; then
                if [[ -f /etc/kubernetes/kubelet.conf ]]; then
                        sed -i "s#server: https://.*\$#server: https://$APISERVER_LB#g" /etc/kubernetes/kubelet.conf
                fi
        fi

        systemctl restart kubelet
}

public::main::clean_cni()
{
    addr=$(ip addr show cni0|grep inet|awk '{print $2}')

    # We need to clean cni0 settings in case of conflict.
    if [ ! -z "$addr" ]; then
        set +e
        kubeadm reset
        ip addr del dev cni0 $addr
        rm -rf /var/lib/cni/*
        docker ps |grep k8s_|awk '{print $1}'|xargs -I '{}' docker stop {}
        set -e
    fi
}

public::main::attach_label() {
        KUBELET_EXTRA_ARGS=""

        if [ $TAINTS != "" ]; then
                TAINT_VARS="--register-with-taints=$TAINTS"
                KUBELET_EXTRA_ARGS="$KUBELET_EXTRA_ARGS $TAINT_VARS"
        fi

        if [ $LABELS != "" ]; then

                LABEL_VARS="--node-labels=$LABELS"
                KUBELET_EXTRA_ARGS="$KUBELET_EXTRA_ARGS $LABEL_VARS"

                if [ "1" == "$GPU_FOUNDED" ]; then
                        sed -i "s#^Environment=\"KUBELET_EXTRA_ARGS=--node-labels=#Environment=\"KUBELET_EXTRA_ARGS=$KUBELET_EXTRA_ARGS,#" /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
                else
                        #sed -i '/^ExecStart=$/iEnvironment="KUBELET_EXTRA_ARGS=--feature-gates=DevicePlugins=true"' /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
                        sed -i "/^ExecStart=$/iEnvironment=\"KUBELET_EXTRA_ARGS=$KUBELET_EXTRA_ARGS\"" /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
                fi
                systemctl daemon-reload
                systemctl restart kubelet

        else
                echo "No extra labels for this node"
        fi
}

public::main::mount_disk() {
        #config /etc/fstab and mount device
        device=$1
        if [ ! -b "$device" ]; then
                echo "mount_disk fail: ${device} is not a block dev"; exit 2
        fi
        set +e
        cat /etc/fstab | grep $device >/dev/null 2>&1
        i=$?
        set -e
        if [ $i -eq 0 ]; then
                echo "disk ${device} is already mounted"; return
        fi

    dev_slave="${device}1"
    if ! tune2fs -l "${dev_slave}" ; then
        echo "Formatting '${dev_slave}'"
        fdisk -S 56 "${device}" <<-EOF
                n
                p
                1


                wq
        EOF
        sleep 5
        mkfs.ext4 -i 8192 "${dev_slave}"
    fi

        docker_flag=0
        if [ -d "/var/lib/docker" ]; then
                docker_flag=1
                service docker stop
                rm -fr /var/lib/docker
        fi
        mkdir /var/lib/docker

        kubelet_flag=0
        if [ -d "/var/lib/kubelet" ]; then
                kubelet_flag=1
                service kubelet stop
                rm -fr /var/lib/kubelet
        fi
        mkdir /var/lib/kubelet

        if [ ! -d /var/lib/container ]; then
                mkdir /var/lib/container/
        fi

        mount -t ext4 ${dev_slave} /var/lib/container/
        mkdir /var/lib/container/kubelet /var/lib/container/docker
        echo "${dev_slave}    /var/lib/container/     ext4    defaults        0 0
/var/lib/container/kubelet /var/lib/kubelet none defaults,bind 0 0
/var/lib/container/docker /var/lib/docker none defaults,bind 0 0" >>/etc/fstab

        mount -a; df -h

        if [ $docker_flag == 1 ]; then
                service docker start
        fi
        if [ $kubelet_flag == 1 ]; then
                service kubelet start
        fi
}

public::main::nvidia_gpu() {
        current_region=$(curl --retry 5 -sSL http://100.100.100.200/latest/meta-data/region-id)
        if [ "" == "$current_region" ]; then
                echo "can not get regionid and instanceid! \
            curl --retry 5 -sSL http://100.100.100.200/latest/meta-data/region-id" && exit 256
        fi
        kube::main::detect_gpu
        if [ "1" == "$GPU_FOUNDED" ]; then
                nvidiaDriverInstallUrl=$PKG_FILE_SERVER/$CLOUD_TYPE/pkg/run/attach/$KUBE_VERSION/nvidia-gpu.sh

                curl --retry 5 -sSL ${nvidiaDriverInstallUrl} -o nvidia-gpu.sh
                chmod u+x nvidia-gpu.sh
                source nvidia-gpu.sh
                public::nvidia::enable_gpu_capability
        else
                echo "Do nothing for non-GPU node"
        fi
        # public::nvidia::deploy_static_pod
}

public::main::deploy_nvidia_plugin() {
        set +e
        kube::main::detect_gpu
        if [ "1" == "$GPU_FOUNDED" ]; then
                public::nvidia::deploy_static_pod
        else
                echo "Do nothing for non-GPU node"
        fi
        set -e
}

kube::main::detect_gpu() {
        set +e
        kube::main::setup_lspci $OS
        lspci | grep -i nvidia >/dev/null 2>&1
        i=$?
        if [ $i -eq 0 ]; then
                export GPU_FOUNDED=1
        fi
        set -e
}

kube::main::setup_lspci() {
        which lspci >/dev/null 2>&1
        i=$?
        if [ $i -ne 0 ]; then
                if [ "$1" == "CentOS" ]; then
                        yum install -y pciutils
                else
                        apt install -y pciutils
                fi
        fi
}

public::common::get_node_info() {
        if [ "$CLOUD_TYPE" == "public" -o "$CLOUD_TYPE" == "private" ]; then
                insid=$(curl --retry 5 -sSL http://100.100.100.200/latest/meta-data/instance-id)
                info=$(curl --retry 5 -H "Date:$(date -R)" -sfSL "$openapi/token/${OPENAPI_TOKEN}/instance/${insid}/node_info" | grep '\w')
                eval "$info"
                export DOCKER_VERSION=$docker_version
                export CLUSTER_DNS=$cluster_dns
                export TOKEN=$token
                export APISERVER_LB=$endpoint
        fi
}

public::common::callback()
{
    if [ "$CLOUD_TYPE" != "agility" ];then
        if [ "$CLOUD_TYPE" == "private" ];then
            callback_url="${callback_url/cs-anony.aliyuncs.com/cs-intranet.inter.env17e.shuguang.com}"
        fi
        curl -H "Date:`date -R`" -X POST -sfSLk "${callback_url}"
        echo "======================================="
        echo "                 SUCCESS               "
        echo "======================================="
    fi
}

public::main::cleanup() {
        addr=$(ip addr show cni0 | grep inet | awk '{print $2}')

        # We need to clean cni0 settings in case of conflict.
        if [ ! -z "$addr" ]; then
                set +e
                ip addr del dev cni0 $addr
                rm -rf /var/lib/cni/*
                docker ps | grep k8s_ | awk '{print $1}' | xargs -I '{}' docker stop {}
                set -e
        fi

                rm -rf /etc/kubernetes

                set +e
                which kubelet >/dev/null 2>&1
                i=$?
                if [ $i -eq 0 ]; then
                        systemctl stop kubelet
                fi
                set -e
}

main() {
        while
                [[ $# -gt 0 ]]
        do
                key="$1"

                case $key in
                --docker-version)
                        export DOCKER_VERSION=$2
                        shift
                        ;;
                --cluster-dns)
                        export CLUSTER_DNS=$2
                        shift
                        ;;
                --token)
                        export TOKEN=$2
                        shift
                        ;;
                --endpoint)
                        export APISERVER_LB=$2
                        shift
                        ;;
                --openapi-token)
                        export OPENAPI_TOKEN=$2
                        shift
                        ;;
                --ess)
                        export FROM_ESS=$2
                        export AUTO_FDISK="true"
                        shift
                        ;;
                --auto-fdisk)
                        export AUTO_FDISK="true"
                        ;;

                --disk-device)
                        export DISK_DEVICE=$2
                        shift
                        ;;
                --labels)
                        export LABELS=$2
                        shift
                        ;;
                --taints)
                        export TAINTS=$2
                        shift
                        ;;
                *)
                        public::common::log "unknown option [$key]"
                        #exit 1
                        ;;
                esac
                shift
        done

        if [ "$OPENAPI_TOKEN" != "" ]; then
                # Using default cidr.
                public::common::get_node_info
        fi

        if [ "$DOCKER_VERSION" == "" ]; then
                # Using default cidr.
                public::common::log "DOCKER_VERSION $DOCKER_VERSION is not set."
                exit 1
        fi

        KUBE_VERSION=$(curl -k https://$APISERVER_LB/version | grep gitVersion | awk '{print $2}' | cut -f2 -d \")
        export KUBE_VERSION=${KUBE_VERSION:1}
        if [ "$KUBE_VERSION" == "" ]; then
                # Using default cidr.
                public::common::log "KUBE_VERSION $KUBE_VERSION is failed to set."
                exit 1
        fi

        if [ "$TOKEN" == "" ]; then
                # Using default cidr.
                public::common::log "TOKEN $TOKEN is not set."
                exit 1
        fi

        if [ "$CLUSTER_DNS" == "" ]; then
                # Using default cidr.
                public::common::log "CLUSTER_DNS $CLUSTER_DNS is not set."
                exit 1
        fi

        public::common::nodeid
        public::common::os_env
        public::common::region

        # Do some clean up
        public::main::cleanup

        # 首先从本地读取相应版本的tar包。当所需要的安装包不存在的时候
        # 如果设置了参数PKG_FILE_SERVER，就从该Server上下载。
        # 如果是在公有云上执行，可以使用内网oss地址
        if [ "$PKG_FILE_SERVER" == "" ]; then
                export PKG_FILE_SERVER=http://aliacs-k8s-$REGION.oss-$REGION-internal.aliyuncs.com
        fi

        # 安装Kubernetes时候会启动一些AddOn插件的镜像。
        # 改插件设置镜像仓库的前缀。
        if [ "$KUBE_REPO_PREFIX" == "" ]; then
                export KUBE_REPO_PREFIX=registry-vpc.$REGION.aliyuncs.com/acs
        fi

        public::main::node_up
        public::main::deploy_nvidia_plugin

        if [ "$OPENAPI_TOKEN" != "" ]; then
                public::common::callback
        fi

}

main "$@"