guia variada

gistfile1.txt

-------------------------------
PUESTA EN MARCHA 
-------------------------------
- generamos la clave con ssh y metemos la publica en github
- clonamos y nos posicionamos
git clone git@github.com:msoranno/mykubeStuff.git
cd mykubeStuff/
- creamos el persistent volume y el claim para jenkins de 1gb
kubectl create -f pv.yaml
kubectl create -f pv-claim.yaml
kubectl get pv
- Creamos el namespace demo
kubectl create namespace demo
- jenkisn vía docker
[msoranno@master ~]$ mkdir jenkinsdata
sudo docker run -itd --network=host -p 8080:8080 -p 50000:50000 -v /home/msoranno/jenkinsdata:/var/jenkins_home --name jenkins docker.io/jenkins/jenkins

- Creamos el jenkins via kubernetes. En el trabajo esto no va, creo que es un tema del cluster que no le he montado bien y tiene problemas de dns
kubectl create -f  myjenkins-deployment_pvc.yaml
- Miramos el progreso
kubectl get pods -n=demo
kubectl get deployments -n demo
-Bajaremos las replicas a 1 por que da problemas luego
kubectl scale deployment/myjenkins --replicas=1 -n demo
- ajustamos firewall
firewall-cmd --state
firewall-cmd --get-default-zone
firewall-cmd --get-zones
firewall-cmd --zone=public --permanent --add-port=8080/tcp
firewall-cmd --zone=public --permanent --add-port=50000/tcp
systemctl restart firewalld
firewall-cmd --list-ports
- Creamos el servicio de kubernets tipo nodeport que nos creará un puerto aleatorio, en esta caso el 30215
 kubectl expose deployment myjenkins --port=8080  --dns 8.8.8.8 --type="NodePort" -n demo
 kubectl get svc -n demo
- en este punto ya podriamos entrar al jenkinn:
	Desde windows haciendo los ajustes de NAT en virtualbox: http://localhost:8080/login?from=%2F
	Desde dentro de la maquina con elinks: elinks 10.0.2.15:30215
- Hacemos lo propio con jenkins , recordando que apunta al NFS
cat /var/nfs/general/secrets/initialAdminPassword


- Dashboard
kubectl create -f https://raw.githubusercontent.com/kubernetes/dashboard/master/src/deploy/recommended/kubernetes-dashboard.yaml

-------------------------------
KUBERNETES
-------------------------------
- Ver configuracion
kubectl config view

- creaciond e un deplyment
kubectl create -f nginx-deployment.yaml

- sacar el yaml
kubectl get deployment nginx-deployment -o yaml

- Actualización directa de la imagen sobre el deplyment que esta vivo
kubectl set image deployment/nginx-deployment nginx=nginx:1.8
Y así monitorizamos el rollout
kubectl rollout status deployment/nginx-deployment

- Ver las historias de los rollouts
kubectl rollout history deployment/nginx-deployment --revision=3

- De esta forma se puede vovler a una version anterior
kubectl rollout undo deployment/nginx-deployment --to-revision=1

- scaling para arriba y para abajo
kubectl scale deployment/nginx-deployment --replicas=3

- Lables y selectos

- Exponiendo puerto, en local se abre uno aleatorio
kubectl expose deployment nginx-deployment --type="NodePort" --port 80
kubectl expose deployment myjenkins --port=8080  --type="NodePort"
kubectl expose deployment wiki-deployment --port=8080  --type="NodePort"

- esto es para el balanceador de aws
kubectl expose deployment nginx-deployment --port=80 --type=LoadBalancer

- Persistent Volume
 kubectl create -f pv.yaml
 kubectl get pv
- Claim
kubectl create -f pv-claim.yaml
kubectl get pvc
- Creamos el claim para jenkins


-----------------------------
Centos7: 16.04 - For Kubernetes
-----------------------------
**conociendo y actualizano**
cat /etc/*release

- Comando yum para saber donde encontrar un paquete
yum whatprovides '*bin/dig'
Respuesta:
32:bind-utils-9.9.4-51.el7.x86_64 : Utilities for querying DNS name servers
Instalamos entonces:
yum install bind-utils

- Cambiando el hotsname
hostnamectl set-hostname master.kube


** instalación de dokcer **
- Nos cambiamos
sudo -i

- Deshabilitamos el swap por que a veces kubernetes da problemas
swapoff -a
vi vi /etc/fstab
# /dev/mapper/centos_maraco-swap swap                    swap    defaults        0 0

- docker
yum -y install docker
systemctl enable docker
- Docker storage
cp /etc/sysconfig/docker-storage-setup /etc/sysconfig/docker-storage-setup.original
vi /etc/sysconfig/docker-storage-setup
DEVS=sdb
VG=docker-vg
docker-storage-setup
- Check
lsblk
lvs
- start docker
systemctl start docker

** instalación de kubernetes **
- Agregamos el repositorio
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF

- Apagamos SELinux
setenforce 0
vi /etc/selinux/config
Dejamos este parametro como permissive
SELINUX=permissive

- instalamos las piezas de kubernetes
yum install -y kubelet kubeadm kubectl

- habilitamos y arrancamos el kubelet
systemctl enable kubelet 
systemctl start kubelet

- cambiaremos unos parametros de comportamiento
cat <<EOF > /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
comprobamos los cambios:
sysctl --system

- Metemos en el fichero hosts

- Arrancaremos kubernetes
kubeadm init --pod-network-cidr=10.244.0.0/16

kubeadm join 10.0.2.15:6443 --token l71jzm.z3iqa5eu45wnq3v8 --discovery-token-ca-cert-hash sha256:d616aa6ae5f676bc09c02e9c60088778fc8df542ce8d674f1e4aa7c0724d9a17

- Hay que salir de root y seguir las instrucciones
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

- Instalación flannel
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.10.0/Documentation/kube-flannel.yml

Despues de esperar un poco podemos ver como el master se pone ready

-- by default los pods no se pueden ejecutar en el master, pero con este comando lo hacemos posible. Hasta que no hacemos esto
el kube-dns-86f4d74b45-5x4ts no arranca
kubectl taint nodes --all node-role.kubernetes.io/master-

-- NFS
firewall-cmd --list-all
firewall-cmd --permanent --zone=public --add-service=ssh (puede que ya este activo)
firewall-cmd --permanent --zone=public --add-service=nfs
firewall-cmd --reload
yum -y install nfs-utils
systemctl enable nfs-server.service
systemctl start nfs-server.service

sudo mkdir -p /var/nfs/general
chown nfsnobody:nfsnobody /var/nfs/general
sudo  vi /etc/exports
/var/nfs/general 10.0.2.15(rw,sync,no_subtree_check)
exportfs -a (para actualizar)
systemctl restart nfs-server.service

-install git
sudo yum -y install git

- En caso de querer volver a instalar kubernets (NO TERMINA DE FUNCIONAR):
HARD:
yum remove -y kubelet kubeadm kubectl
yum install -y kubelet kubeadm kubectl
systemctl enable kubelet
systemctl stop docker
rm -rf /var/lib/etcd/*
rm -rf /etc/kubernetes/manifests/etcd.yaml /etc/kubernetes/manifests/kube-scheduler.yaml 
rm -rf /etc/kubernetes/manifests/kube-controller-manager.yaml /etc/kubernetes/manifests/kube-apiserver.yaml
systemctl stop firewalld
systemctl start docker
kubeadm init --pod-network-cidr=10.244.0.0/16
SOFT:
systemctl stop kubelet && systemctl stop docker &&  systemctl stop firewalld
rm -rf /var/lib/etcd/*
rm -rf /etc/kubernetes/manifests/etcd.yaml /etc/kubernetes/manifests/kube-scheduler.yaml 
rm -rf /etc/kubernetes/manifests/kube-controller-manager.yaml /etc/kubernetes/manifests/kube-apiserver.yaml
systemctl start docker
borramos contenedores:
docker rm $(docker ps -aq)
borramos imagenes:
docker rmi k8s.gcr.io/kube-proxy-amd64:v1.10.0
docker rmi k8s.gcr.io/kube-apiserver-amd64:v1.10.0
docker rmi k8s.gcr.io/kube-scheduler-amd64:v1.10.0
docker rmi k8s.gcr.io/kube-controller-manager-amd64:v1.10.0
docker rmi k8s.gcr.io/etcd-amd64:3.1.12
docker rmi k8s.gcr.io/pause-amd64:3.1




-----------------------------
UBUNTU: 16.04 - For Kubernetes
-----------------------------
**conociendo y actualizano**
cat /etc/*release

sudo apt-get upgrade

sudo apt-get update

**Docker**
sudo -i 

apt install docker.io

cat << EOF > /etc/docker/daemon.json
{
"exec-opts": ["native.cgroupdriver=systemd"]
}
EOF

sudo usermod -a -G docker ubuntu

**Kubernetes** (esto hay que hacerlo en todos los miembros del cluster)
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -

cat <<EOF > /etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF

apt update

apt -y install kubectl kubelet kubeadm

-Arracamos usando flannel
kubeadm init --pod-network-cidr=10.244.0.0/16

- Nos quedamos con el comando de join que nos dan:
kubeadm join 172.31.23.50:6443 --token mf1svy.uodwdx9p2p5e6qxo --discovery-token-ca-cert-hash sha256:2c48059d6dd98d766207e05caf878e72047383c6ba5b4d663d7203e93f9e7979

- Para poder usar el cluster 
 . Salir de root y volver al usuario normal
 . Copiamos la configuración en nuestro home.
	mkdir -p $HOME/.kube
	sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
	sudo chown $(id -u):$(id -g) $HOME/.kube/config

- Ya podriamos comenzar a usar kubctl
	kubectl get pods --all-namespaces
	Se puede observar que el kube-dns-86f4d74b45-k2kh7 está pendind, eso es por que flannel no está arrancado
	todavía.

- Le aplicamos el yaml
	kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/v0.10.0/Documentation/kube-flannel.yml

- Repetimos y deberiamos ver todo corriendo.
	kubectl get pods --all-namespaces
	kubectl get nodes 

- by default los pods no se pueden ejecutar en el master, pero con este comando lo hacemos posible
kubectl taint nodes --all node-role.kubernetes.io/master-


**NFS**
 sudo apt-get install nfs-kernel-server nfs-common
 sudo mkdir -p /var/nfs/general
 sudo chown nobody:nogroup /var/nfs/general

sudo  vi /etc/exports
/var/nfs/general 172.31.23.50(rw,sync,no_subtree_check)

sudo systemctl restart nfs-kernel-server



----------------------------------
**GO** ()instalación y pruebilla)
----------------------------------
sudo curl -O https://storage.googleapis.com/golang/go1.9.1.linux-amd64.tar.gz

sudo tar -xvf go1.9.1.linux-amd64.tar.gz

sudo mv go /usr/local

vi .profile
export PATH=$PATH:/usr/local/go/bin

source .profile

go version

mkdir goWork

export GOPATH=$HOME/goWork

mkdir -p goWork/src/github.com/user/hello

vi goWork/src/github.com/user/hello/hello.go

package main
import "fmt"
func main() {
    fmt.Printf("hello, world\n")
}

go install github.com/user/hello

sudo $GOPATH/bin/hello

- Crear una imagen pequeña
https://blog.codeship.com/building-minimal-docker-containers-for-go-applications/

**Puertos**
- Prueba
netstat -tuplen | grep 80
sudo python -m SimpleHTTPServer 80
-Apertura
iptables -F
iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp -m tcp --dport 443 -j ACCEPT
-ufw
https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firewall-with-ufw-on-ubuntu-16-04

**DockerFile**
FROM golang:latest 
RUN mkdir /app 
ADD . /app/ 
WORKDIR /app 
RUN go build wiki.go
EXPOSE 8080
CMD ["/app/wiki"]
- creacion del docker
ubuntu@ip-172-31-23-50:~/goWork/src/wiki$ sudo docker build -t wiki .

------------------------
AWS
------------------------
Foto interesante de lo que podría ser un montaje de kubernetes básico
https://www.weave.works/technologies/kubernetes-on-aws/

-------------------------
Minishift
-------------------------
sudo apt install qemu-kvm libvirt-bin
sudo gpasswd -a $(whoami) libvirtd
newgrp libvirtd
sudo -i
curl -L https://github.com/dhiltgen/docker-machine-kvm/releases/download/v0.10.0/docker-machine-driver-kvm-ubuntu16.04 > /usr/local/bin/docker-machine-driver-kvm
chmod +x /usr/local/bin/docker-machine-driver-kvm
wget https://github.com/minishift/minishift/releases/download/v1.15.1/minishift-1.15.1-linux-amd64.tgz
tar xvzf minishift-1.15.1-linux-amd64.tgz
cd minishift-1.15.1-linux-amd64
chmod 755 minishift
mv minishift /usr/local/bin/
minishift start


---------------------------------
jenkins
---------------------------------
- habilitar el API de docker
sudo vi /lib/systemd/system/docker.service
ExecStart=/usr/bin/docker daemon -H fd:// -H tcp://0.0.0.0:4243

sudo systemctl daemon-reload
sudo systemctl restart docker

curl http://localhost:4243/version

- Ejecutar  docker run con el fichero hosts del host
docker run -itd --network=host -p 8080:8080 -p 50000:50000 -v /home/msoranno/jenkinsdata:/var/jenkins_home --name jenkins jenkins/jenkins:latest