AI 助理
备案控制台
开发者社区 云原生 文章 正文

Shell脚本快速部署Kubernetes(K8S v1.1版本)集群系统

2017-11-28 1623
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

提醒：即使按照本篇文章一步一步做，也不一定部署成功。原因你懂得！如果失败，也建议你仔细看看脚本内容，从中寻找解决办法。同时，相信你也会从脚本中获取到其他有价值的信息。

实验环境：

操作系统：Ubuntu14.04_x64

master：192.168.1.150

minion01 : 192.168.1.151  容器网段：172.17.1.0/24

minion02 : 192.168.1.152  容器网段：172.17.2.0/24

安装包下载：

etcd：http://pan.baidu.com/s/1c1wITMw

kubernetes：http://pan.baidu.com/s/1kUoxgYb

相关脚本下载：http://pan.baidu.com/s/1o7nEaca

脚本说明：

config_ssh_root_remote.sh     #配置root SSH登录（默认ubuntu系统禁止root SSH登录）

ssh_keypair_auth.sh         #配置master主机与minion主机SSH免交互认证

kubernetes-install.sh        #安装kubernetes的master端与minion端

config_gre_channel.sh        #配置两台Docker主机容器实现跨主机访问（OVS）

安装步骤（请按照步骤做）：

1）在minion主机root权限开启root允许SSH远程登录

操作命令：$ sudo bash config_ssh_root_remote.sh

脚本内容：$ cat config_ssh_root_remote.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#!/bin/bash
# Description: configuration root account ssh remote login
if  [ $USER !=  "root"  ];  then
     echo  "Please use root account operation or sudo!"
     exit  1
fi
function  color_echo() {
     if  [ $1 ==  "green"  ];  then
         echo  -e  "\033[32;40m$2\033[0m"
     elif  [ $1 ==  "red"  ];  then
         echo  -e  "\033[31;40m$2\033[0m"
     fi
}
function  check_pkg() {
     if  ! $(dpkg -l $PKG_NAME > /dev/null  2>&1);  then
         echo  no
     else
         echo  yes
     fi
}
function  install_pkg() {
     local  PKG_NAME=$1
     if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
         apt-get  install  $PKG_NAME -y
         if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
             color_echo green  "$PKG_NAME installation failure! Try to install again."
             apt-get autoremove && apt-get update
             apt-get  install  $PKG_NAME --force- yes  -y
             [ $(check_pkg $PKG_NAME) ==  "no"  ] && color_echo red  "The $PKG_NAME installation failure!"  &&  exit  1
         fi
     fi
}
install_pkg expect
# modify ssh config file
sed  -r -i  's/(PermitRootLogin).*/\1 yes/'  /etc/ssh/sshd_config
service  ssh  restart > /dev/null
# set root account password
echo  "------------------------------------------------------>"
while  true ;  do
     read  -p  "Please enter you want to set the root account password: "  ROOT_PASS
     if  [ -n  "$ROOT_PASS"  ];  then
         break
     else
         color_echo red  "Password cannot be empty!"
         continue
     fi
done
expect -c "
     spawn  passwd  root
     expect {
         \"Enter new UNIX password:\" {send \"$ROOT_PASS\r\"; exp_continue}
         \"Retype new UNIX password:\" {send \"$ROOT_PASS\r\"}
     }
     expect eof
" > /dev/null
color_echo green  "The root account password is: $ROOT_PASS"

2）在master主机切换到root用户执行脚本与minion主机root用户建立SSH免交互登录

操作命令：# bash ssh_keypair_auth.sh root@192.168.1.151-152@123

脚本内容：# cat ssh_keypair_auth.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#!/bin/bash
# Description: configuration local host and remote host ssh keypair authentication, Support Ubuntu and CentOS operation system.
function  color_echo() {
     if  [ $1 ==  "green"  ];  then
         echo  -e  "\033[32;40m$2\033[0m"
     elif  [ $1 ==  "red"  ];  then
         echo  -e  "\033[31;40m$2\033[0m"
     fi
}
function  os_version() {
     local  OS_V=$( cat  /etc/issue  | awk  'NR==1{print $1}' )
     if  [ $OS_V ==  "\S"  -o $OS_V ==  "CentOS"  ];  then
         echo  "CentOS"
     elif  [ $OS_V ==  "Ubuntu"  ];  then
         echo  "Ubuntu"
     fi
}
function  check_ssh_auth() {
     if  $( grep  "Permission denied"  $EXP_TMP_FILE > /dev/null );  then
         color_echo red  "Host $IP SSH authentication failure! Login password error."
         exit  1
     elif  $( ssh  $INFO  'echo yes >/dev/null' );  then
         color_echo green  "Host $IP SSH authentication successfully."
     fi
     rm  $EXP_TMP_FILE > /dev/null
}
function  check_pkg() {
     local  PKG_NAME=$1
     if  [ $(os_version) ==  "CentOS"  ];  then
         if  ! $(rpm -ql $PKG_NAME > /dev/null  2>&1);  then
             echo  no
         else
             echo  yes
         fi
     elif  [ $(os_version) ==  "Ubuntu"  ];  then
         if  ! $(dpkg -l $PKG_NAME > /dev/null  2>&1);  then
             echo  no
         else
             echo  yes
         fi
     fi
}
function  install_pkg() {
     local  PKG_NAME=$1
     if  [ $(os_version) ==  "CentOS"  ];  then
         if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
             yum  install  $PKG_NAME -y
             if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
                 color_echo green  "The $PKG_NAME installation failure! Try to install again."
                 yum makecache
                 yum  install  $PKG_NAME -y
                 [ $(check_pkg $PKG_NAME) ==  "no"  ] && color_echo red  "The $PKG_NAME installation failure!"  &&  exit  1
             fi
         fi
     elif  [ $(os_version) ==  "Ubuntu"  ];  then
         if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
             apt-get  install  $PKG_NAME -y
             if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
                 color_echo green  "$PKG_NAME installation failure! Try to install again."
                 apt-get autoremove && apt-get update
                 apt-get  install  $PKG_NAME --force- yes  -y
                 [ $(check_pkg $PKG_NAME) ==  "no"  ] && color_echo red  "The $PKG_NAME installation failure!"  &&  exit  1
             fi
         fi
     fi
}
function  generate_keypair() {
     if  [ ! -e ~/. ssh /id_rsa .pub ];  then
         color_echo green  "The public/private rsa key pair not exist, start Generating..."
         expect -c "
             spawn  ssh -keygen
             expect {
                 \" ssh /id_rsa ):\" {send \"\r\";exp_continue}
                 \"passphrase):\" {send \"\r\";exp_continue}
                 \"again:\" {send \"\r\";exp_continue}
             }
         " > /dev/null  2>&1
         if  [ -e ~/. ssh /id_rsa .pub ];  then
             color_echo green  "Generating public/private rsa key pair successfully."
         else
             color_echo red  "Generating public/private rsa key pair failure!"
             exit  1
         fi
     fi
}
EXP_TMP_FILE= /tmp/expect_ssh .tmp
if  [[ $1 =~ ^[a-z]+@[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}@.* ]];  then
     install_pkg expect ; generate_keypair
     for  i  in  $@;  do
         USER=$( echo  $i| cut  -d@ -f1)
         IP=$( echo  $i| cut  -d@ -f2)
         PASS=$( echo  $i| cut  -d@ -f3)
         INFO=$USER@$IP
         expect -c "
             spawn  ssh -copy- id  $INFO
             expect {
                 \"( yes /no )?\" {send \" yes \r\";exp_continue}
                 \"password:\" {send \"$PASS\r\";exp_continue}
             }
         " > $EXP_TMP_FILE   # if login failed, login error info append temp file
         check_ssh_auth
     done
elif  [[ $1 =~ ^[a-z]+@[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}-[0-9]{1,3}@.* ]];  then
     install_pkg expect ; generate_keypair
     START_IP_NUM=$( echo  $1| sed  -r  's/.*\.(.*)-(.*)@.*/\1/' )
     END_IP_NUM=$( echo  $1| sed  -r  's/.*\.(.*)-(.*)@.*/\2/' )
     for  ((i=$START_IP_NUM;i<=$END_IP_NUM;i++));  do
         USER=$( echo  $1| cut  -d@ -f1)
         PASS=$( echo  $1| cut  -d@ -f3)
         IP_RANGE=$( echo  $1| sed  -r  's/.*@(.*\.).*/\1/' )
         IP=$IP_RANGE$i
         INFO=$USER@$IP_RANGE$i
         expect -c "
             spawn  ssh -copy- id  $INFO
             expect {
                 \"( yes /no )?\" {send \" yes \r\";exp_continue}
                 \"password:\" {send \"$PASS\r\";exp_continue}
             }
         " > $EXP_TMP_FILE
         check_ssh_auth
     done
else
     echo  "Example1: $0 <root@192.168.1.10-15@password>"
     echo  "Example2: $0 <root@192.168.1.10@password>"
     echo  "Example3: $0 [root@192.168.1.10@password root@192.168.1.11@password root@192.168.1.12@password ...]"
fi

3）在master主机root权限执行脚本安装master端服务

操作命令：$ sudo bash kubernetes-install.sh master

脚本内容：$ cat kubernetes-install.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
#!/bin/bash
# Description: Installation Kubernetes1.1.3
# Etcd Download: https://github.com/coreos/etcd/releases/download/v2.2.2/etcd-v2.2.2-linux-amd64.tar.gz
# K8S Download: https://storage.googleapis.com/kubernetes-release/release/v1.1.3/kubernetes.tar.gz
.  /lib/lsb/init-functions
if  [ $( cat  /etc/issue  | awk  '{print $1}' ) !=  "Ubuntu"  ];  then
     echo  "Only support ubuntu operating system!"
     exit  1
fi
if  [ $USER !=  "root"  ];  then
     echo  "Please use root account operation!"
     exit  1
fi
function  color_echo() {
     if  [ $1 ==  "green"  ];  then
         echo  -e  "\033[32;40m$2\033[0m"
     elif  [ $1 ==  "red"  ];  then
         echo  -e  "\033[31;40m$2\033[0m"
     fi
}
function  check_install_pkg() {
     if  [ ! -e $ETCD_FILE -a ! -e $K8S_FILE ];  then
         color_echo red  "$ETCD_FILE and $K8S_FILE file not exist!"
         exit  1
     elif  [ ! -e $ETCD_FILE ];  then
         color_echo red  "$ETCD_FILE file not exist!"
         exit  1
     elif  [ ! -e $K8S_FILE ];  then
         color_echo red  "$K8S_FILE file not exist!"
         exit  1
     fi
}
function  local_ip() {
     local  NUM ARRAY_LENGTH 
     NUM=0
     for  NIC_NAME  in  $( ls  /sys/class/net | grep  -vE  "lo|docker0" );  do
         NIC_IP=$( ifconfig  $NIC_NAME | awk  -F '[: ]+'  '/inet addr/{print $4}' )
         if  [ -n  "$NIC_IP"  ];  then
             NIC_IP_ARRAY[$NUM]= "$NIC_NAME:$NIC_IP"
             let  NUM++
         fi
     done
     ARRAY_LENGTH=${ #NIC_IP_ARRAY[*]}
     if  [ $ARRAY_LENGTH - eq  1 ];  then
         LOCAL_IP=${NIC_IP_ARRAY[0] #*:}
         return  0
     elif  [ $ARRAY_LENGTH - eq  0 ];  then
         color_echo red  "No available network card!"
         exit  1
     else
         # multi network card select
         for  NIC  in  ${NIC_IP_ARRAY[*]};  do
             echo  $NIC
         done
         while  true ;  do
             read  -p  "Please enter local use to network card name: "  INPUT_NIC_NAME
             for  NIC  in  ${NIC_IP_ARRAY[*]};  do
                 NIC_NAME=${NIC%:*}
                 if  [ $NIC_NAME ==  "$INPUT_NIC_NAME"  ];  then
                     LOCAL_IP=${NIC_IP_ARRAY[0] #*:}
                     return  0
                 fi
             done
             echo  "Not match! Please input again."
         done
     fi
}
function  check_ip() {
     local  IP=$1
     VALID_CHECK=$( echo  $IP| awk  -F.  '$1<=255&&$2<=255&&$3<=255&&$4<=255{print "yes"}' )
     if  echo  $IP| grep  -E  "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$"  > /dev/null ;  then
         if  [ ${VALID_CHECK:-no} ==  "yes"  ];  then
             return  0
         else
             echo  "IP $IP not available!"
             return  1
         fi
     else
         echo  "IP format error!"
         return  1
     fi
}
function  cluster_ip() {
     if  [ $1 ==  "master"  ];  then
         while  true ;  do
             read  -p  "Please enter master IP: "  MASTER_IP
             check_ip $MASTER_IP
             [ $? - eq  0 ] &&  break
         done
     elif  [ $1 ==  "minion"  ];  then
         while  true ;  do
             local  MINION_NUM
             read  -p  "Please enter cluster minion node number: "  MINION_NUM
             if  [[ $MINION_NUM =~ ^[0-9]+$ ]];  then
                 break
             else
                 color_echo red  "Format error!"
             fi
         done
         NUM=1
         while  [ $NUM - le  $MINION_NUM ];  do
             local  MINION_IP
             read  -p  "Please enter minion host $NUM IP: "  MINION_IP
             check_ip $MINION_IP
             if  [ $? - eq  0 ];  then
                 let  NUM++
                 MINION_IP_ARRAY+=($MINION_IP)
             fi
         done
     fi
}
function  modify_init_script() {
     if  [ $1 ==  "master"  ];  then
         cd  $MASTER_MODULE_INIT_SCRIPT_DIR
     elif  [ $1 ==  "minion"  ];  then
         cd  $MINION_MODULE_INIT_SCRIPT_DIR
     fi
     for  MODULE_INIT_SCRIPT  in  $( ls | grep  - v  etcd);  do
         if  [ -x $MODULE_INIT_SCRIPT ];  then
             sed  -r -i  '/\/sbin\/initctl/{s/(if)(.*)/\1 false \&\&\2/}'  $MODULE_INIT_SCRIPT
         fi
     done
}
function  check_service_status() {
     sleep  1
     if  [ $( ps  -ef | grep  - v  grep | grep  -c  "$BIN_DIR/$MODULE_INIT_SCRIPT" ) - eq  1 ];  then
         log_begin_msg  "Starting $MODULE_INIT_SCRIPT"
         log_end_msg 0  # 0 is the right command execution status
     else
         log_failure_msg  "$(color_echo red " Starting $MODULE_INIT_SCRIPT ")"
         log_end_msg 1  # 1 is the wrong command execution status
     fi
}
function  check_exec_status() {
     if  [ $? - ne  0 ];  then
         color_echo green  "Please try to run the script!"
         exit  1
     fi
}
BASE_DIR=$PWD
ETCD_FILE=$BASE_DIR /etcd-v2 .2.2-linux-amd64. tar .gz
K8S_FILE=$BASE_DIR /kubernetes . tar .gz
BIN_DIR= /opt/bin
INIT_SCRIPT_DIR= /etc/init .d
OPTS_FILE_DIR= /etc/default
MODULE_BIN_DIR=$BASE_DIR /kubernetes/server/bin
MASTER_MODULE_INIT_SCRIPT_DIR=$BASE_DIR /kubernetes/cluster/ubuntu/master/init_scripts
MINION_MODULE_INIT_SCRIPT_DIR=$BASE_DIR /kubernetes/cluster/ubuntu/minion/init_scripts
case  $1  in
master)
     check_install_pkg
     pkill etcd ; pkill kube
     cluster_ip minion
     # Create binary file directory
     [ ! -d $BIN_DIR ] &&  mkdir  $BIN_DIR
     # Installation storage system etcd
     log_action_msg  "Unzip the $ETCD_FILE"
     tar  zxf $ETCD_FILE ; check_exec_status
     cp  $BASE_DIR /etcd-v2 .2.2-linux-amd64 /etc * $BIN_DIR ; check_exec_status
     echo  "
     ETCD_OPTS=\"\
     --listen-client-urls http: //0 .0.0.0:4001 \
     --advertise-client-urls http: //0 .0.0.0:4001 \
     --data- dir  /var/lib/etcd/default .etcd\"
     " > $OPTS_FILE_DIR /etcd
     # Installation module kube-apiserver kube-scheduler and kube-controller-manager
     log_action_msg  "Unzip the $K8S_FILE"
     tar  zxf $BASE_DIR /kubernetes . tar .gz ; check_exec_status
     tar  zxf $BASE_DIR /kubernetes/server/kubernetes-server-linux-amd64 . tar .gz ; check_exec_status
     cd  $MODULE_BIN_DIR &&  cp  -a kubectl kube-apiserver kube-scheduler kube-controller-manager $BIN_DIR ; check_exec_status
     # Configure init scripts
     modify_init_script master
     cp  -a etcd kube-* $INIT_SCRIPT_DIR ; check_exec_status
     sed  -i  '63s/.*/"/'  $INIT_SCRIPT_DIR /etcd   #Remove the append log file,Otherwise etcd may cannot be started
     # Module Configure option
     log_action_msg  "Create $OPTS_FILE_DIR/kube-apiserver startup options file ..."
     echo  "
     KUBE_APISERVER_OPTS=\"\
     --insecure-bind-address=0.0.0.0 \
     --insecure-port=8080 \
     --service-cluster-ip-range=10.0.0.0 /16  \
     --etcd_servers=http: //127 .0.0.1:4001 \
     --logtostderr= true \"
     " > $OPTS_FILE_DIR /kube-apiserver
     check_exec_status
     log_action_msg  "Create $OPTS_FILE_DIR/kube-controller-manager startup options file ..."
     echo  "
     KUBE_CONTROLLER_MANAGER_OPTS=\"\
     --master=127.0.0.1:8080 \
     --logtostderr= true \"
     " > $OPTS_FILE_DIR /kube-controller-manager
     log_action_msg  "Create $OPTS_FILE_DIR/kube-scheduler startup options file ..."
     echo  "
     KUBE_SCHEDULER_OPTS=\"\
     --master=127.0.0.1:8080 \
     --logtostderr= true \"
     " > $OPTS_FILE_DIR /kube-scheduler
     # Starting module
     for  MODULE_INIT_SCRIPT  in  $( ls  $INIT_SCRIPT_DIR| grep  -E  "(etcd|kube.*)" );  do
         service $MODULE_INIT_SCRIPT start > /dev/null
         check_service_status
     done
     # set variable
     echo  "export PATH=$PATH:$BIN_DIR"  >>  /etc/profile
     .  /etc/profile
     # Copy module kubelet and kube-proxy to minion
     SSH_OPTS= "-o ConnectTimeout=1 -o ConnectionAttempts=3"
     cd  $MODULE_BIN_DIR
     for  MINION_IP  in  ${MINION_IP_ARRAY[*]};  do
         log_action_msg  "Copy module to $MINION_IP:$BIN_DIR ..."
         ssh  $SSH_OPTS root@$MINION_IP  "mkdir $BIN_DIR 2>/dev/null"  ; check_exec_status
         scp  $SSH_OPTS kubelet kube-proxy root@$MINION_IP:$BIN_DIR
     done
     # Copy module init scripts to minion
     modify_init_script minion
     cd  $MINION_MODULE_INIT_SCRIPT_DIR
     for  MINION_IP  in  ${MINION_IP_ARRAY[*]};  do
         log_action_msg  "Copy module init scripts to $MINION_IP:$INIT_SCRIPT_DIR ..."
         scp  $SSH_OPTS kubelet kube-proxy root@$MINION_IP:$INIT_SCRIPT_DIR ; check_exec_status
     done
     color_echo green  "Kubernetes master installation complete."
     ;;
minion)
     cluster_ip master  # Notice input master ip
     local_ip
     pkill kube
     # Install Docker
     if  ! $(dpkg -l docker-engine > /dev/null  2>&1) && ! $(docker info > /dev/null  2>&1);  then
         log_action_msg  "Start the installation Docker ..."
         apt-key adv --keyserver hkp: //p80 .pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D > /dev/null  2>&1
         [ $? - ne  0 ] &&  echo  "Docker source secret key register failure!"
         DOCKER_U_SOURCE= /tmp/docker_source .tmp
         echo  "
         deb https: //apt .dockerproject.org /repo  ubuntu-precise main
         deb https: //apt .dockerproject.org /repo  ubuntu-trusty main
         deb https: //apt .dockerproject.org /repo  ubuntu-vivid main
         deb https: //apt .dockerproject.org /repo  ubuntu-wily main
         " > $DOCKER_U_SOURCE
         OS_CODE_V=$(lsb_release -cs)
         DOKER_SOURCE=$( grep  $OS_CODE_V $DOCKER_U_SOURCE)
         echo  "$DOKER_SOURCE"  >  /etc/apt/sources .list.d /docker .list
         rm  $DOCKER_U_SOURCE
         apt-get update
         apt-get  install  docker-engine  -y
         if  $(dpkg -l docker-engine > /dev/null ) && $(docker info > /dev/null );  then
             color_echo green  "Docker installation successfully."
         else
             apt-get remove ; apt-get  install  docker-engine --force- yes  -y
             if  ! $(dpkg -l docker-engine > /dev/null ) && ! $(docker info > /dev/null );  then
                 color_echo red  "Docker installation failure!"
                 exit  1
             fi
         fi
     fi
     # Module Configure option
     log_action_msg  "Create $OPTS_FILE_DIR/kubelet startup options file ..."
     echo  "
     KUBELET_OPTS=\"\
     --address=0.0.0.0 \
     --port=10250 \
     --hostname_override=$LOCAL_IP \
     --api_servers=http: // $MASTER_IP:8080 \
     --pod-infra-container-image=docker.io /kubernetes/pause :latest \
     --logtostderr= true \"
     " > $OPTS_FILE_DIR /kubelet
     log_action_msg  "Create $OPTS_FILE_DIR/kube-proxy startup options file ..."
     echo  "
     KUBE_PROXY_OPTS=\"\
     --master=http: // $MASTER_IP:8080 \
     --proxy-mode=iptables \
     --logtostderr= true \"
     " > $OPTS_FILE_DIR /kube-proxy
     # Starting module
     for  MODULE_INIT_SCRIPT  in  $( ls  $INIT_SCRIPT_DIR| grep  kube.*);  do
         service $MODULE_INIT_SCRIPT start > /dev/null
         check_service_status
     done
     color_echo green  "Kubernetes minion installation complete."
     ;;
*)
     echo  "Usage: $0 {master|minion}"
     exit  1
     ;;
esac

4）在minion主机root权限执行脚本安装minion端服务

操作命令：$ sudo bash kubernetes-install.sh minion

脚本内容：同上

5）在minion主机root权限执行脚本创建GRE通道

操作命令：$ sudo bash config_gre_channel.sh

脚本内容：$ cat config_gre_channel.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#!/bin/bash
# Description: configuration docker host between GRE Channel
if  [ $( cat  /etc/issue  | awk  '{print $1}' ) !=  "Ubuntu"  ];  then
     echo  "Only support ubuntu operating system!"
     exit  1
fi
if  [ $USER !=  "root"  ];  then
     echo  "Please use root account operation!"
     exit  1
fi
function  color_echo() {
     if  [ $1 ==  "green"  ];  then
         echo  -e  "\033[32;40m$2\033[0m"
     elif  [ $1 ==  "red"  ];  then
         echo  -e  "\033[31;40m$2\033[0m"
     fi
}
function  check_ip() {
     local  IP=$1
     local  VALID_CHECK=$( echo  $IP| awk  -F.  '$1<=255&&$2<=255&&$3<=255&&$4<=255{print "yes"}' )
     if  echo  $IP| grep  -E  "^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$"  > /dev/null ;  then
         if  [ ${VALID_CHECK:-no} ==  "yes"  ];  then
             return  0
         else
             echo  "IP $IP not available!"
             return  1
         fi
     else
         echo  "IP format error!"
         return  1
     fi
}
function  docker_host_ip() {
         color_echo green  "Notice: Only support two Docker host configuration GRE Channel!"
         NUM=1
         while  [ $NUM - le  2 ];  do
             local  DOCKER_IP
             read  -p  "Please enter Docker host $NUM IP: "  DOCKER_HOST_IP
             check_ip $DOCKER_HOST_IP
             if  [ $? - eq  0 ];  then
                 let  NUM++
                 DOCKER_HOST_IP_ARRAY+=($DOCKER_HOST_IP)
             fi
         done
}
function  local_nic_info() {
     local  NUM ARRAY_LENGTH
     NUM=0
     for  NIC_NAME  in  $( ls  /sys/class/net | grep  -vE  "lo|docker0" );  do
         NIC_IP=$( ifconfig  $NIC_NAME | awk  -F '[: ]+'  '/inet addr/{print $4}' )
         if  [ -n  "$NIC_IP"  ];  then
             NIC_IP_ARRAY[$NUM]= "$NIC_NAME:$NIC_IP"
             let  NUM++
         fi
     done
     ARRAY_LENGTH=${ #NIC_IP_ARRAY[*]}
     if  [ $ARRAY_LENGTH - eq  1 ];  then
         LOCAL_NIC=${NIC_IP_ARRAY[0]%:*}
         LOCAL_IP=${NIC_IP_ARRAY[0] #*:}
         return  0
     elif  [ $ARRAY_LENGTH - eq  0 ];  then
         color_echo red  "No available network card!"
         exit  1
     else
         # multi network card select
         for  NIC  in  ${NIC_IP_ARRAY[*]};  do
             echo  $NIC
         done
         while  true ;  do
             read  -p  "Please enter local use to network card name: "  INPUT_NIC_NAME
             for  NIC  in  ${NIC_IP_ARRAY[*]};  do
                 NIC_NAME=${NIC%:*}
                 if  [ $NIC_NAME ==  "$INPUT_NIC_NAME"  ];  then
                     LOCAL_NIC=${NIC_IP_ARRAY[0]%:*}
                     LOCAL_IP=${NIC_IP_ARRAY[0] #*:}
                     return  0
                 fi
             done
             echo  "Not match! Please input again."
         done
     fi
}
function  check_pkg() {
     if  ! $(dpkg -l $PKG_NAME > /dev/null  2>&1);  then
         echo  no
     else
         echo  yes
     fi
}
function  install_pkg() {
     local  PKG_NAME=$1
     if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
         apt-get  install  $PKG_NAME -y
         if  [ $(check_pkg $PKG_NAME) ==  "no"  ];  then
             color_echo green  "The $PKG_NAME installation failure! Try to install again."
             apt-get autoremove && apt-get update
             apt-get  install  $PKG_NAME --force- yes  -y
             [ $(check_pkg $PKG_NAME) ==  "no"  ] && color_echo red  "The $PKG_NAME installation failure!"  &&  exit  1
         fi
     fi
}
function  config_gre_channel() {
     install_pkg openvswitch-switch
     install_pkg bridge-utils
     if  [ ${DOCKER_HOST_IP_ARRAY[0]} ==  "$LOCAL_IP"  ];  then
         REMOTE_HOST_IP=${DOCKER_HOST_IP_ARRAY[1]}   # remote host ip
         REMOTE_DOCKER_IP= "172.17.2.0/24"    # remote docker host default container ip range
         LOCAL_DOCKER_IP= "172.17.1.0"     # kbr0 gateway
     elif  [ ${DOCKER_HOST_IP_ARRAY[1]} ==  "$LOCAL_IP"  ];  then
         REMOTE_HOST_IP=${DOCKER_HOST_IP_ARRAY[0]}
         REMOTE_DOCKER_IP= "172.17.1.0/24"
         LOCAL_DOCKER_IP= "172.17.2.0"
     else
         echo  "IP not match! Please input again."
         exit  1
     fi
     ovs-vsctl add-br obr0 2> /dev/null
     ovs-vsctl add-port obr0 gre0 --  set  Interface gre0  type =gre options:remote_ip=$REMOTE_HOST_IP 2> /dev/null
     brctl addbr kbr0 2> /dev/null
     brctl addif kbr0 obr0 2> /dev/null
     ip link  set  dev kbr0 up
     if  [ $( grep  -cE  "kbr0"  /etc/network/interfaces ) - ne  2 ];  then
         echo  "
auto kbr0
iface kbr0 inet static
     address $( echo  $LOCAL_DOCKER_IP| sed  's/0$/1/' )
     netmask 255.255.255.0
     gateway $LOCAL_DOCKER_IP
     bridge_ports obr0
         " >>  /etc/network/interfaces
     fi
     if  $( ls  /sys/class/net | grep  docker0 > /dev/null );  then
         service docker stop > /dev/null
         ip link  set  dev docker0 down
         ip link delete dev docker0
         echo  "DOCKER_OPTS=\"-b=kbr0\""  >  /etc/default/docker
         service docker start > /dev/null
     fi
     ifdown kbr0 > /dev/null  2>&1;ifup kbr0 > /dev/null  2>&1
     # reboot invalid
     # ip route add $REMOTE_DOCKER_IP via $REMOTE_HOST_IP dev $LOCAL_NIC 2>/dev/null
     # permanent valid
     if  ! $( grep  "$REMOTE_DOCKER_IP via $REMOTE_HOST_IP"  /etc/rc . local  > /dev/null );  then
         sed  -i  "$i\ip route add $REMOTE_DOCKER_IP via $REMOTE_HOST_IP dev $LOCAL_NIC"  /etc/rc . local
     fi
}
# main
docker_host_ip
echo  "--------------------------------------------"
local_nic_info
config_gre_channel
color_echo green  "GRE Channel configuration complete."
brctl show
echo  "-------------------------------------------------"
ovs-vsctl show

1、配置minion主机root SSH登录

先将config_gre_channel.sh、config_ssh_root_remote.sh和kubernetes-install.sh这三个文件上传各自的minion主机，以备后用。

wKioL1andomgjPzmAAD-8-Se6Yg166.png

wKiom1andkaDYH9eAAD822Zk8Yc240.png

说明：操作成功，root密码为123

2、配置master主机与minion主机SSH免交互认证

将kubernetes-install.sh、ssh_keypair_auth.sh和etcd-v2.2.2-linux-amd64.tar.gz、kubernetes.tar.gz安装包上传到master主机

wKioL1anfPHSocP8AAFe0BuIpdE717.png

3、安装master端

wKiom1anfMOhxMGRAAEnHE9-0xo326.png

wKiom1anfMHyTuqPAABtz-gdRfg226.png

说明：先解压文件，在创建启动选项文件，再启动服务，最后将minion相关包通过scp工具拷贝过去。通过ps工具看到服务进程已经启动。

4、安装minion端

wKioL1anfSThIlsEAAChm8MNlUA958.png

wKiom1anfODCwaHzAAAJgrqzPOk731.png

wKiom1anfOHS46TXAABvfDFm83I151.png

wKiom1anfOLTXeGQAACj6FqqGHM390.png

wKioL1anfSfCAGSzAABw9U_zMk8117.png

说明：Docker源秘钥注册失败，没关系，一般不会影响安装。当提示安装docker成功后才能继续，否则报错退出。通过ps 工具看到服务进程都已经启动。

5、配置GRE通道

wKioL1anfT7RPXUTAACwJWoCUv4740.png

wKiom1anfPqCAWhWAAA51f8PrdE569.png

wKiom1anfReiSA5vAACzQM6IonA001.png

wKioL1anfVzTXLJ-AAA5gWNmQtw962.png

说明：目前配置GRE通道脚本只支持两台Docker主机

6、查看集群是否配置成功

# 通过kubectl命令创建一个pod

wKiom1anfTbTGsCIAABuYAxrgj0402.png

wKioL1anfXvQkIkuAAA-n25o8cM998.png

说明：在master端可以看到两台minion端状态是Ready，并且创建的Pod已经成功运行。

注意：如果没有kubectl命令，先尝试执行source /etc/profile下看看，如果还没有，直接使用/opt/bin/kubectl



本文转自 李振良OK 51CTO博客，原文链接：http://blog.51cto.com/lizhenliang/1738807，如需转载请自行联系原作者

文章标签：
容器服务Kubernetes版
Shell
容器
Kubernetes
网络安全
Ubuntu
关键词：
Shell脚本
容器服务Kubernetes版kubernetes
容器服务Kubernetes版集群
容器服务Kubernetes版k8s
部署容器服务Kubernetes版
相关实践学习
深入解析Docker容器化技术
Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，相互之间不会有任何接口。Docker是世界领先的软件容器平台。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。运维人员利用Docker可以在隔离容器中并行运行和管理应用，获得更好的计算密度。企业利用Docker可以构建敏捷的软件交付管道，以更快的速度、更高的安全性和可靠的信誉为Linux和Windows Server应用发布新功能。 在本套课程中，我们将全面的讲解Docker技术栈，从环境安装到容器、镜像操作以及生产环境如何部署开发的微服务应用。本课程由黑马程序员提供。 &nbsp; &nbsp; 相关的阿里云产品：容器服务 ACK 容器服务 Kubernetes 版（简称 ACK）提供高性能可伸缩的容器应用管理能力，支持企业级容器化应用的全生命周期管理。整合阿里云虚拟化、存储、网络和安全能力，打造云端最佳容器化应用运行环境。 了解产品详情: https://www.aliyun.com/product/kubernetes
技术小阿哥
目录
相关文章
IvanCodes
|
20天前
|
存储 安全 Unix
七、Linux Shell 与脚本基础
别再一遍遍地敲重复的命令了，把它们写进Shell脚本，就能一键搞定。脚本本质上就是个存着一堆命令的文本文件，但要让它“活”起来，有几个关键点：文件开头最好用#!/usr/bin/env bash来指定解释器，并用chmod +x给它执行权限。执行时也有讲究：./script.sh是在一个新“房间”（子Shell）里跑，不影响你；而source script.sh是在当前“房间”里跑，适合用来加载环境变量和配置文件。
IvanCodes
264 9
IvanCodes
|
20天前
|
存储 Shell Linux
八、Linux Shell 脚本：变量与字符串
Shell脚本里的变量就像一个个贴着标签的“箱子”。装东西（赋值）时，=两边千万不能有空格。用单引号''装进去的东西会原封不动，用双引号""则会让里面的$变量先“变身”再装箱。默认箱子只能在当前“房间”（Shell进程）用，想让隔壁房间（子进程）也能看到，就得给箱子盖个export的“出口”戳。此外，Shell还自带了$?（上条命令的成绩单）和$1（别人递进来的第一个包裹）等许多特殊箱子，非常有用。
IvanCodes
110 2
winx_19970108018
|
1月前
|
数据采集 监控 Shell
无需Python：Shell脚本如何成为你的自动化爬虫引擎？
Shell脚本利用curl/wget发起请求，结合文本处理工具构建轻量级爬虫，支持并行加速、定时任务、增量抓取及分布式部署。通过随机UA、异常重试等优化提升稳定性，适用于日志监控、价格追踪等场景。相比Python，具备启动快、资源占用低的优势，适合嵌入式或老旧服务器环境，复杂任务可结合Python实现混合编程。
winx_19970108018
102 0
盹猫
|
3月前
|
Web App开发 缓存 安全
Linux一键清理系统垃圾:释放30GB空间的Shell脚本实战​
这篇博客介绍了一个实用的Linux系统盘清理脚本，主要功能包括： 安全权限检查和旧内核清理，保留当前使用内核 7天以上日志文件清理和系统日志压缩 浏览器缓存(Chrome/Firefox)、APT缓存、临时文件清理 智能清理Snap旧版本和Docker无用数据 提供磁盘空间使用前后对比和大文件查找功能 脚本采用交互式设计确保安全性，适合定期维护开发环境、服务器和个人电脑。文章详细解析了脚本的关键功能代码，并给出了使用建议。完整脚本已开源，用户可根据需求自定义调整清理策略。
盹猫
293 1
科技小先锋
|
Shell
shell脚本实现对系统的自动分区
科技小先锋
988 0
蓝易云
|
4月前
|
Shell
Shell脚本循环控制：shift、continue、break、exit指令
使用这些命令可以让你的Shell脚本像有生命一样动起来。正确使用它们，你的脚本就能像一场精心编排的舞蹈剧目，既有旋律的起伏，也有节奏的跳跃，最终以一场惊艳的表演结束。每一个动作、每一个转折点，都准确、优雅地完成所需要表达的逻辑。如此，你的脚本不只是冰冷的代码，它透过终端的界面，跳着有节奏的舞蹈，走进观众——使用者的心中。
蓝易云
214 60
1786310562865821
|
7月前
|
关系型数据库 MySQL Shell
MySQL 备份 Shell 脚本：支持远程同步与阿里云 OSS 备份
一款自动化 MySQL 备份 Shell 脚本，支持本地存储、远程服务器同步（SSH+rsync）、阿里云 OSS 备份，并自动清理过期备份。适用于数据库管理员和开发者，帮助确保数据安全。
1786310562865821
271 0
蓝易云
|
5月前
|
存储 Unix Shell
确定Shell脚本在操作系统中的具体位置方法。
这对于掌握Linux的文件系统组织结构和路径方面的理解很有帮助，是我们日常工作和学习中都可能使用到的知识。以上讲解详细清晰，应用简便，是每一个想要精通操作系统的计算机爱好者必备的实用技能。
蓝易云
124 17
刘大猫.
|
5月前
|
Linux Shell
Centos或Linux编写一键式Shell脚本删除用户、组指导手册
Centos或Linux编写一键式Shell脚本删除用户、组指导手册
刘大猫.
142 4
刘大猫.
|
5月前
|
Linux Shell 数据安全/隐私保护
Centos或Linux编写一键式Shell脚本创建用户、组、目录分配权限指导手册
Centos或Linux编写一键式Shell脚本创建用户、组、目录分配权限指导手册
刘大猫.
306 3

热门文章

最新文章

  • 1
    基于 Azure DevOps 与阿里云 ACK 构建企业级 CI/CD 流水线
  • 2
    七、Linux Shell 与脚本基础
  • 3
    八、Linux Shell 脚本：变量与字符串
  • 4
    阿里云容器服务ACK云原生AI套件测评
  • 5
    使用阿里云容器服务Kubernetes实现蓝绿发布功能
  • 6
    Hadoop大数据平台实战(05)：深入Spark Cluster集群模式YARN vs Mesos vs Standalone vs K8s
  • 7
    Kubernetes中的Pod无法访问外网-Ubuntu16.04 LTS
  • 8
    Kubernetes Meetup深秋成都行 Ghostcloud精灵云获好评如云
  • 9
    二进制安装Kubernetes（k8s） v1.24.0 IPv4/IPv6双栈
  • 10
    K8s安装部署--超级详细（无坑，v1.23）
  • 1
    确定Shell脚本在操作系统中的具体位置方法。
    124
  • 2
    Centos或Linux编写一键式Shell脚本创建用户、组、目录分配权限指导手册
    306
  • 3
    Centos或Linux编写一键式Shell脚本删除用户、组指导手册
    142
  • 4
    shell_42：Linux参数移动
    109
  • 5
    在Linux、CentOS7中设置shell脚本开机自启动服务
    481
  • 6
    在MySQL Shell里 重启MySQL 8.4实例
    171
  • 7
    Shell 输出命令完全指南：echo 与 printf 的深度剖析
    311
  • 8
    MySQL 备份 Shell 脚本：支持远程同步与阿里云 OSS 备份
    272
  • 9
    微服务2——MongoDB单机部署2——Shell连接
    181
  • 10
    定期备份数据库：基于 Shell 脚本的自动化方案
    267

    • 相关课程

    更多
  • 阿里云 EMR on ACK 实战
  • 阿里云K8S微服务部署案例
  • Kubernetes极速入门
  • Serverless 容器从入门到精通: - Serverless Kubernetes
  • Kubernetes云原生管理实践
  • Kubernetes入门

    • 相关电子书

    更多
  • ACK 云原生弹性方案—云原生时代的加速器
  • ACK集群类型选择最佳实践
  • 企业运维之云原生和Kubernetes 实战

    • 推荐镜像

    更多
  • kubernetes
    • 下一篇
    阿里云无影云电脑免费使用_免费申请教程