Instalalción Kubernetes v1.

5 en Centos7

Actualizar todo los paquetes del SO

# yumn update

Para no utilizar DNS escribir nombre de cada nodo en el hosts

master,minion1,minion2# vi /etc/hosts

10.150.106.136 master master.syachile.cl

10.150.106.139 minion1 minion1.syachile.cl
10.150.106.134 minion2 minion2.syachile.cl

Agregar al repositorio de archivos los paquetes del Kubernetes

master,minion1,minion2# vi /etc/yum.repos.d/virt7-docker-common-release.repo
[virt7-docker-common-release]
name=virt7-docker-common-release
baseurl=http://cbs.centos.org/repos/virt7-docker-common-release/x86_64/os/
gpgcheck=0

Luego instalar los paquetes necesarios para kubernetes

master# yum install kubernetes flannel etcd
minion1,minion2# yum install kubernetes flannel

Desactivar firewall en todos los servidores

master,minion1,minion2# systemctl stop firewalld
master,minion1,minion2# systemctl disable firewalld

Luego desactivamos la opcion SELINUX

master,minion1,minion2# vi /etc/selinux/config
cambiamos la linea
SELINUX=enforcing
por
SELINUX=disabled

master,minion1,minion2# reboot

Configuración de Kubernetes en el MASTER

master# vi /etc/kubernetes/config

Buscamos la palabra KUBE_MASTER y agregamos lo siguiente:

KUBE_MASTER="--master=http://10.150.106.136:8080" //esta es la IP del nodo
master

Modificamos el fichero /etc/kubernetes/apiserver

master# vi /etc/kubernetes/apiserver
ANTIGUO → KUBE_API_ADDRESS="--insecure-bind-address=127.0.0.1"
NUEVO → KUBE_API_ADDRESS="--address=0.0.0.0"

ANTIGUO → KUBE_ETCD_SERVERS="--etcd-servers=http://127.0.0.1:2379"
NUEVO → KUBE_ETCD_SERVERS="--etcd-servers=http://10.150.106.136:2379"

comentar
#KUBE_ADMISSION_CONTROL="--
admissioncontrol=NamespaceLifecycle,NamespaceExists,LimitRanger,SecurityContextDeny
,ServiceAccount,ResourceQuota"
Luego modificamos el archivo de etcd y modificamos las variables a continuación

master# vi /etc/etcd/etcd.conf
ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379"
ETCD_ADVERTISE_CLIENT_URLS="http://0.0.0.0:2379"

Luego reiniciamos los servicio

master# for SERVICES in etcd kube-apiserver kube-controllermanager kube-scheduler;

do
> systemctl restart $SERVICES
> systemctl enable $SERVICES
> systemctl status $SERVICES
> done

Definición de una red FLANNEL, esta se utiliza para comunicación interna entre cada
servidores

master# vi flannel-config.json
{
"Network": "10.0.10.0/16",
"SubnetLen": 24,
"Backend": {
"Type": "vxlan",
"VNI": 1
}
}

En el fichero de configuración /etc/sysconfig/flanneld vemos la URL Y el lugar del

archivo para etcd.

master# vi /etc/sysconfig/flanneld
buscamos
FLANNEL_ETCD_KEY="/atomic.io/network"

por lo tanto, agregamos el archivo a la ruta

master# etcdctl set /atomic.io/network/config < flannel-config.json

lo verificamos

master# etcdctl get /atomic.io/network/config

{
"Network": "10.0.10.0/16",
"SubnetLen": 24,
"Backend": {
"Type": "vxlan",
"VNI": 1
}
}

Configuración de Kubernetes en los MINIONS

Le indicamos al minion donde se encuentra el master

minion1# vi /etc/kubernetes/config
bascamos
KUBE_MASTER="--master=http://127.0.0.1:8080"
cambiamos a
KUBE_MASTER="--master=http://10.150.106.136:8080"

Proporcionamos información sobre la API y hostname del servidores

minion1# vi /etc/kubernetes/kubelet
buscamos las siguientes lineas
KUBELET_ADDRESS="--address=127.0.0.1"
KUBELET_HOSTNAME="--hostname-override=127.0.0.1"
KUBELET_API_SERVER="--api-servers=http://127.0.0.1:8080"

las cambiamos a
KUBELET_ADDRESS="--address=0.0.0.0"
KUBELET_HOSTNAME="--hostname-override=minion1"
KUBELET_API_SERVER="--api-servers=http://10.150.106.136:8080"

Red FLANNEL

minion1# vi /etc/sysconfig/flanneld
buscamos
FLANNEL_ETCD_ENDPOINTS="http://127.0.0.1:2379"
modificamos a
FLANNEL_ETCD_ENDPOINTS="http://10.150.106.136:2379"

Reiniciamos los servicios

minion1# for SERVICES in kube-proxy kubelet docker flanneld; do
systemctl restart $SERVICES
systemctl enable $SERVICES
systemctl status $SERVICES
done

Comprobamos la red y la API de kubernetes

curl -s http://10.150.106.136:2379/v2/keys/atomic.io/network/subnets | python
-mjson.tool
{
"action": "get",
"node": {
"createdIndex": 564,
"dir": true,
"key": "/atomic.io/network/subnets",
"modifiedIndex": 564,
"nodes": [
{
"createdIndex": 564,
"expiration": "2017-08-18T15:38:27.465222013Z",
"key": "/atomic.io/network/subnets/10.0.72.0-24",
"modifiedIndex": 564,
"ttl": 86031,
"value":
"{\"PublicIP\":\"10.150.106.139\",\"BackendType\":\"vxlan\",\"BackendData\":
{\"VtepMAC\":\"3a:28:12:bc:03:1e\"}}"
}
]
}
}

verificamos que el master reconoce el nodo

master# kubectl get node
NAME STATUS AGE
minion1 Ready 7m
Configuración de Docker sobre Kubernetes

Debemos proporcionar la contraseña de nuestro repositorio

master# kubectl create secret docker-registry my-secret --docker-
server=https://index.docker.io/v1/ --docker-username=fgazmuri --docker-
password=[password] --docker-email=francisco.gazmuri@gmail.com

Subir servicio docker

master# systemctl start docker
master# systemctl enable docker
master# docker login

Crear archivo Dokerfile

master# vi Dockerfile
FROM centos
RUN yum install -y java-1.8.0-openjdk.x86_64 unzip
//Paquetes necesarios para instalar
ADD wildfly-10.1.0.Final.zip /wildfly-10.1.0.Final.zip
//archivo bajado desde la pagina del wildfly
RUN unzip /wildfly-10.1.0.Final.zip
ENV JBOSS_HOME /wildfly-10.1.0.Final
RUN $JBOSS_HOME/bin/add-user.sh admin admin123 --silent=true

EXPOSE 8080 9990

CMD ["/wildfly-10.1.0.Final/bin/standalone.sh", "-b", "0.0.0.0", "-bmanagement",

"0.0.0.0"]

Crear imagen Docker

master# docker build -t fgazmuri/wildfly8 . //debes estar donde este el archivo
Dockerfile
Ver si la imagen quedo configurada
master# docker images
REPOSITORY TAG IMAGE ID CREATED
SIZE
fgazmuri/wildfly8 latest ec61951be834 41 minutes ago
745.2 MB
docker.io/centos latest 328edcd84f1b 13 days ago
192.5 MB

Subir imagen a hub.docker.com

docker push fgazmuri/wildfly8

Con esto ya podemos utilizar nuestra imagen Docker para Kubernetes, ahora debemos
implementarla como servicio
Crear archivo Deployments en lenguaje yaml
master# vi Deployment_WildFly.yaml
apiVersion: extensions/v1beta1
#apiVersion: v1
kind: Deployment
metadata:
name: wildfly
spec:
replicas: 2 #Crear 2 replicas una en cada servidor
minion
template:
metadata:
labels:
app: wildfly
 spec:
containers:
- name: wildfly
image: fgazmuri/wildfly8 #nombre del repositorio Docker
ports:
- containerPort: 8080 #Puerto http publico
name: web
- containerPort: 9990 #Puerto de administracion
name: admin

Ahora crear el servicio que expondra nuestro deployments

master# vi Service_WildFly.yaml
kind: Service
apiVersion: v1
metadata:
name: wildfly
spec:
type: LoadBalancer
selector:
app: wildfly
ports:
- name: web #Nombre del containerPort
protocol: TCP
port: 8081 #Puerto de salida desde la maquina fisica del minion
targetPort: 8080 #Puerto de salida desde la maquina virtual del minion
- name: admin
protocol: TCP
port: 9991
targetPort: 9990

Verificamos nuestro servicio

master# kubectl get all
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
deploy/wildfly 2 2 2 2 52m

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE

svc/kubernetes 10.254.0.1 <none> 443/TCP 4h
svc/wildfly 10.254.204.210 <pending> 8081:32152/TCP,9991:31388/TCP 50m

NAME DESIRED CURRENT READY AGE

rs/wildfly-3446662864 2 2 2 52m

NAME READY STATUS RESTARTS AGE

po/wildfly-3446662864-s0bd2 1/1 Running 0 52m
po/wildfly-3446662864-t94kh 1/1 Running 0 52m

Con esto ya se puede acceder a los servicios desde lo siguientes puertos:

http://minion1:32152 //Servicio Web

http://minion1:31388 //Consola administrativa
http://minion2:32152 //Servicio Web
http://minion2:31388 //Consola administrativa

Actualizar un Deployments

Se debe trabajar con la imagen de un POD dentro del Minion1 o 2 luego realizar
commmit del docker con el siguiente comando
minion1# docker commit -a "fgazmuri" -m "version 1.1" [uid_container]
fgazmuri/wildfly8:1.1
el uid_container se obtiene con el comando
minion1# docker ps

Luego en el master

Luego actualizar imagen

master# kubectl edit deployment/wildfly

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file
will be
# reopened with the relevant failures.
#
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
annotations:
deployment.kubernetes.io/revision: "2"
creationTimestamp: 2017-08-18T14:19:18Z
generation: 2
labels:
app: wildfly
name: wildfly
namespace: default
resourceVersion: "94811"
selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/wildfly
uid: 38ffa3bb-8420-11e7-b34e-506b8d2b1f31
spec:
replicas: 2
selector:
matchLabels:
app: wildfly
name: wildfly
namespace: default
resourceVersion: "94811"
selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/wildfly
uid: 38ffa3bb-8420-11e7-b34e-506b8d2b1f31
spec:
replicas: 2
selector:
matchLabels:
app: wildfly
strategy:
rollingUpdate:
maxSurge: 1
maxUnavailable: 1
type: RollingUpdate
template:
metadata:
creationTimestamp: null
labels:
app: wildfly
spec:
containers:
- image: fgazmuri/wildfly8:1.1 #Se debe cambiar la version
imagePullPolicy: Always
name: wildfly
 ports:
- containerPort: 8080
name: web
protocol: TCP
- containerPort: 9990
name: admin
protocol: TCP
resources: {}
terminationMessagePath: /dev/termination-log
dnsPolicy: ClusterFirst
restartPolicy: Always
securityContext: {}
terminationGracePeriodSeconds: 30
status:
availableReplicas: 2
conditions:
- lastTransitionTime: 2017-08-18T14:19:21Z
lastUpdateTime: 2017-08-18T14:19:21Z
message: Deployment has minimum availability.
reason: MinimumReplicasAvailable
status: "True"
type: Available
observedGeneration: 2
replicas: 2
updatedReplicas: 2

Se debe aplicar el cambio

master# kubectl rollout status deployment/wildfly

Seteo de parametros y volumen persistente

Par crear un volumen persistente se debe crear el siguiente archivo donde crea el
volumne para le sistema

apiVersion: v1
kind: PersistentVolume
metadata:
name: local-home-test
labels:
type: local
spec:
capacity:
storage: 20Gi
accessModes:
- ReadWriteOnce
hostPath:
path: /home/volumenes/wildfly

Ahora se debe crear el volumen persistene este es el que le setea al Deployments

apiVersion: v1
kind: PersistentVolume
metadata:
name: local-home-test
labels:
type: local
spec:
capacity:
 storage: 20Gi
accessModes:
- ReadWriteOnce
hostPath:
path: /home/volumenes/wildfly

Para agregar el volumen y asignarle memoria restringida se deben agregar las lineas
al archivo de Deployments

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: wildfly
spec:
replicas: 2
template:
metadata:
labels:
app: wildfly
spec:
containers:
- name: wildfly
image: fgazmuri/wildfly8:1.1
ports:
- containerPort: 8080
name: web
- containerPort: 9990
name: admin
volumeMounts:
- name: wildfly
mountPath: /test //Ruta que vera el Pods
resources:
requests:
memory: 128Mi
cpu: 100m
limits:
memory: 512Mi
cpu: 250m
volumes:
- name: wildfly
persistentVolumeClaim:
claimName: wildfly-pv-claim //Nombre del claim se puede
verificar con #kubectl get pvc