Using Kubctl to deploy application

#Imperatively working with your cluster. Run will "generate" a Deployment by default.

#This is pulling a specified image from Google's container registry.

#kubectl run, will convert a pod creation into a "Deployment generator"

#http://kubernetes.io/docs/user-guide/kubectl-conventions/#generators 

#UPDATE: Starting in kubernetes 1.18 kubectl run creates a pod rather than a deployment. 

#In lecuture he used below command to create Deployment

#kubectl run hello-world --image=gcr.io/google-samples/hello-app:1.0

#To create a deployment, we need kubectl create deployment

#1st Pod

kubectl create deployment hello-world --image=gcr.io/google-samples/hello-app:1.0

#But let's deploy a single pod too...

#2nd Pod

kubectl run hello-world-pod --image=gcr.io/google-samples/hello-app:1.0 --generator=run-pod/v1

#Let's follow our pod and deployment status

#Will list all PODS. In output we will see 1st and 2nd pod. Pod created by deployment will have unique identfier suffixed.

kubectl get pods

#Will list the deployment. We will see 1 deployment with name hello-world

kubectl get deployment

#Below command will give more details about pod -> IP and Node

kubectl get pods -o wide

#Remember, k8s is a container orchestrator and it's starting up containers on Nodes.

#Open a second terminal and ssh into the node that hello-world pod is running on.

ssh aen@c1-node1

#Will list above 2 pods including the system pod

sudo docker ps

exit

#Back on the Master, we can pull the logs from the container. Which is going to be anything written to stdout. 

#Maybe something went wrong inside our app, and our pod won't start. This is useful for troubleshooting.

#Below command gave message "Server listening on Port 8080"

kubectl logs hello-world-pod

#Starting a process inside a container inside a pod.

#We can use this to launch any process as long as the executable/binary is in the container.

#Launch a shell into the container. Callout that this is on the *pod* network.

kubectl exec -it hello-world-pod  -- /bin/sh

hostname

ip addr

exit

#Remember that first kubectl run we executed, it created a Deployment for us.

#Let's look more closely at the deployment

#Deployments are made of ReplicaSets! and ReplicaSets are made up of POD

#Below command ouput: Name Ready Up-To-Date Available AGE, Ready will say how many replicas are available

kubectl get deployment hello-world

#Will print replicaset name, will also show DESIRED and CURRENT state

kubectl get replicaset

kubectl get pods

#Let's take a closer look at our pod.

#Walk through the pods Events...

#Name, Containers, Ports, Conditions, and Events. 

#Deployments are made of ReplicaSets!

#Will get more details like replicas, labels, annotation, selectors, strategy, Pod Template

kubectl describe deployment hello-world | more

#Let's see what describe can tell us about a deployed Pod.

#Check out the Name, Node, Status, Containers, and events.

kubectl get pods

#Will get node details, IP, which replica is using this pod, container details, mounts

kubectl describe pods $PASTEPODNAMEHERE | more

#Expose the Deployment as a Serivce.

#This will create a Service for the ReplicaSet behind the Deployment

#We are exposing our serivce on port 80, connecting to an application running on 8080 in our pod.

#Port: Interal Cluster Port, the Service's port. You will point cluster resources here.

#TargetPort: The Pod's Serivce Port, your application. That one we defined when we started the pods.

kubectl expose deployment hello-world --port=80 --target-port=8080

#Check out the IP: and Port:, that's where we'll access this service.

#The IP which got exposed is only to inside the cluster, there is different method to expose outside cluster

kubectl get service hello-world

#We can also get that information from using get

#We can see the enpoints which is the pod IP. In our case we will see only one

kubectl describe service hello-world

#Access the service inside the cluster

curl http://$SERVCIEIP:$PORT

#Access the pod's application directly, useful for troubleshooting.

kubectl get endpoints hello-world

curl http://$ENDPOINT:$TARGETORT

#Using kubectl to generate yaml or json files of our imperitive configuration.

kubectl get service hello-world -o yaml

kubectl get service hello-world -o json

#UPDATE: --export has been deprecated. #We'll use dry-run below to create these yaml files

#Exported resources are stripped of cluster-specific information.

#kubectl get service hello-world -o yaml --export > service-hello-world.yaml

#kubectl get deployment hello-world -o yaml --export > deployment-hello-world.yaml

#ls *.yaml

#more service-hello-world.yaml

#We can ask the API for more information about an object

kubectl explain service | more

#And drill down further if needed, includes very good explanation of what's available for that resource

kubectl explain service.spec | more

kubectl explain service.spec.ports

kubectl explain service.spec.ports.targetPort

#Let's remove everything we created imperitively and start over using a declarative model

kubectl delete service hello-world

kubectl delete deployment hello-world

kubectl delete pod hello-world-pod

kubectl get all

#Deploying applications declarativly

#we can use apply to create our resources from yaml.

kubectl create deployment hello-world --image=gcr.io/google-samples/hello-app:1.0 --dry-run=client -o yaml > deployment-hello-world.yaml

more deployment-hello-world.yaml

kubectl apply -f deployment-hello-world.yaml

kubectl expose deployment hello-world --port=80 --target-port=8080 --dry-run=client -o yaml > service-hello-world.yaml 

more service-hello-world.yaml 

kubectl apply -f service-hello-world.yaml 

#This creates everything we created, but in yaml

kubectl get all

#scale up our deployment

vi deployment-hello-world.yaml

Change replicas from 1 to 2

     replicas: 2

#update our configuration with apply

kubectl apply -f deployment-hello-world.yaml

#And check the current configuration of our deployment

kubectl get deployment hello-world

#Repeat the curl access to see the load balancing of the HTTP request

kubectl get service hello-world

curl http://$SERVICEIP:PORT

#We can edit the resources "on the fly" with kubectl edit. But this isn't reflected in our yaml. But is

#persisted in the etcd database...cluster store. Change 2 to 3.

kubectl edit deployment hello-world

#Let's clean up our deployment and remove everything

kubectl delete deployment hello-world

kubectl delete service hello-world

kubectl get all

Kubectl commands

#Listing and Inspecting your cluster, pods, services and more.

kubectl cluster-info

#review status and roles

kubectl get nodes

#Additional information about each node in the cluster. 

kubectl get nodes -o wide

#Let's get a list of pods...but there isn't any running.

kubectl get pods 

#True, but let's get a list of system pods. A namespace is a way to group resources together.

kubectl get pods --namespace kube-system

#Let's get additional information about each pod. 

kubectl get pods --namespace kube-system -o wide

#Now let's get a list of everything that's running in all namespaces

kubectl get all --all-namespaces | more

#Asking kubernetes for the resources it knows about

#Let's look at the headers in each column. Name, Alias/shortnames, API Group (or where that resource is in the k8s API Path),

#Is the resource in a namespace, for example StorageClass issn't and is available to all namespaces and finally Kind...this is the object type.

kubectl api-resources | head -n 10

#We can easily filter using group

kubectl api-resources | grep pod

#Explain an indivdual resource in detail

kubectl explain pod | more 

kubectl explain pod.spec | more 

kubectl explain pod.spec.containers | more 

#You'll soon find your favorite alias

kubectl get no

#Let's take a closer look at our nodes using Describe

#Check out Name, Taints, Conditions, Addresses, System Info, Non-Terminated Pods, and Events

kubectl describe nodes c1-master1

kubectl describe nodes c1-node1

#Ok, so now that we're tired of typing commands out, let's enable bash auto-complete of our kubectl commands

sudo apt-get install bash-completion

echo "source <(kubectl completion bash)" >> ~/.bashrc

source ~/.bashrc

kubectl g[tab][tab] po[tab][tab] --all[tab][tab]

kubectl -h | more

kubectl get -h | more

kubectl describe -h | more 

Google Kubernetes

#Instructions from this URL: https://cloud.google.com/sdk/docs/quickstart-debian-ubuntu

# Create environment variable for correct distribution

CLOUD_SDK_REPO="cloud-sdk-$(lsb_release -c -s)"

# Add the Cloud SDK distribution URI as a package source

echo "deb http://packages.cloud.google.com/apt $CLOUD_SDK_REPO main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

# Import the Google Cloud Platform public key

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

# Update the package list and install the Cloud SDK

sudo apt-get update 

sudo apt-get install google-cloud-sdk

#Authenticate our console session with gcloud

gcloud init --console-only

#Create a named gcloud project

gcloud projects create psdemogke --name="Kubernetes-Cloud"

#Set our current project context

gcloud config set project psdemogke

#Enable GKE services in our current project

gcloud services enable container.googleapis.com

#You may have to adjust your resource limits and enabled billing here based on your subscription here.

#Go to https://console.cloud.google.com

#From the Navigation menu on the top left, browse to Compute->Kubernetes Engine.

#Click enable billing. Click Set Account.

#Tell GKE to create a single zone, three node cluster for us. 3 is the default size.

#https://cloud.google.com/compute/quotas#checking_your_quota

gcloud container clusters create cscluster --region us-central1-a

#Get our credentials for kubectl

gcloud container clusters get-credentials cscluster --zone us-central1-a --project psdemogke

#Check out out lists of kubectl contexts

kubectl config get-contexts

#set our current context to the GKE context

kubectl config use-context gke_psdemogke_us-central1-a_cscluster

#run a command to communicate with our cluster.

kubectl get nodes

#Delete our GKE cluster

#gcloud container clusters delete cscluster --zone=us-central1-a 

#Delete our project.

#gcloud projects delete psdemogke

#Get a list of all contexts on this system.

kubectl config get-contexts

#Let's set to the kubectl context back to our local custer

kubectl config use-context kubernetes-admin@kubernetes

#use kubectl get nodes

kubectl get nodes

Azure AKS - Kubernetes

# This demo will be run from c1-master1 since kubectl is already installed there.

# This can be run from any system that has the Azure CLI client installed.

#Ensure Azure CLI command line utilitles are installed

#https://docs.microsoft.com/en-us/cli/azure/install-azure-cli-apt?view=azure-cli-latest

AZ_REPO=$(lsb_release -cs)

echo "deb [arch=amd64] https://packages.microsoft.com/repos/azure-cli/ $AZ_REPO main" | sudo tee /etc/apt/sources.list.d/azure-cli.list

sudo apt-key --keyring /etc/apt/trusted.gpg.d/Microsoft.gpg adv --keyserver packages.microsoft.com --recv-keys BC528686B50D79E339D3721CEB3E94ADBE1229CF

sudo apt-get update

sudo apt-get install azure-cli

#Log into our subscription

az login

az account set --subscription "Demonstration Account"

#Create a resource group for the serivces we're going to create

az group create --name "Kubernetes-Cloud" --location centralus

#Let's get a list of the versions available to us, 

az aks get-versions --location centralus -o table

#let's check out some of the options available to us when creating our managed cluster

az aks create -h | more

#Let's create our AKS managed cluster. 

az aks create \

    --resource-group "Kubernetes-Cloud" \

    --generate-ssh-keys \

    --name CSCluster \

    --node-count 3 #default Node count is 3

#If needed, we can download and install kubectl on our local system.

az aks install-cli

#Get our cluster credentials and merge the configuration into our existing config file.

#This will allow us to connect to this system remotely using certificate based user authentication.

az aks get-credentials --resource-group "Kubernetes-Cloud" --name CSCluster

#List our currently available contexts

kubectl config get-contexts

#set our current context to the Azure context

kubectl config use-context CSCluster

#run a command to communicate with our cluster.

kubectl get nodes

#Get a list of running pods, we'll look at the system pods since we don't have anything running.

#Since the API Server is HTTP based...we can operate our cluster over the internet...esentially the same as if it was local using kubectl.

kubectl get pods --all-namespaces

#az aks delete --resource-group "Kubernetes-Cloud" --name CSCluster #--yes --no-wait

Kubernetes Node Setup steps

#For this demo ssh into c1-node1

ssh aen@c1-node1

#Disable swap, swapoff then edit your fstab removing any entry for swap partitions

#You can recover the space with fdisk. You may want to reboot to ensure your config is ok. 

swapoff -a

vi /etc/fstab

#Add the Google's apt repository gpg key

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

#Add the kuberentes apt repository

sudo bash -c 'cat <<EOF >/etc/apt/sources.list.d/kubernetes.list

deb https://apt.kubernetes.io/ kubernetes-xenial main

EOF'

#Update the package list 

sudo apt-get update

apt-cache policy kubelet | head -n 20 

#Install the required packages, if needed we can request a specific version

sudo apt-get install -y docker.io kubelet kubeadm kubectl

sudo apt-mark hold docker.io kubelet kubeadm kubectl

#Check the status of our kubelet and our container runtime, docker.

#The kubelet will enter a crashloop until it's joined

sudo systemctl status kubelet.service 

sudo systemctl status docker.service 

#Ensure both are set to start when the system starts up.

sudo systemctl enable kubelet.service

sudo systemctl enable docker.service

#Setup Docker daemon. This is a change that has been added since the recording of the course.

sudo bash -c 'cat > /etc/docker/daemon.json <<EOF

{

  "exec-opts": ["native.cgroupdriver=systemd"],

  "log-driver": "json-file",

  "log-opts": {

    "max-size": "100m"

  },

  "storage-driver": "overlay2"

}

EOF'

sudo systemctl daemon-reload

sudo systemctl restart docker

#If you didn't keep the output, on the master, you can get the token.

kubeadm token list

#If you need to generate a new token, perhaps the old one timed out/expired.

kubeadm token create

#On the master, you can find the ca cert hash.

openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | openssl rsa -pubin -outform der 2>/dev/null | openssl dgst -sha256 -hex | sed 's/^.* //'

#Using the master (API Server) IP address or name, the token and the cert has, let's join this Node to our cluster.

sudo kubeadm join 172.16.94.10:6443 \

    --token 9woi9e.gmuuxnbzd8anltdg \

    --discovery-token-ca-cert-hash sha256:f9cb1e56fecaf9989b5e882f54bb4a27d56e1e92ef9d56ef19a6634b507d76a9

#Back on master, this will say NotReady until the networking pod is created on the new node. Has to schedule the pod, then pull the container.

kubectl get nodes 

#On the master, watch for the calico pod and the kube-proxy to change to Running on the newly added nodes.

kubectl get pods --all-namespaces --watch

#Still on the master, look for this added node's status as ready.

kubectl get nodes

#GO BACK TO THE TOP AND DO THE SAME FOR c1-node2.

#Just SSH into c1-node2 and run the commands again.

ssh aen@c1-node2

#You can skip the token re-creation if you have one that's still valid.

Kubernetes Create Master Node Steps

#Only on the master, download the yaml files for the pod network.

#The calico yaml file has changed since the publication of the course and is now avaialble at the URL below.

wget https://docs.projectcalico.org/manifests/calico.yaml

#Look inside calico.yaml and find the network range CALICO_IPV4POOL_CIDR, adjust if needed.

vi calico.yaml

#Create our kubernetes cluster, specifying a pod network range matching that in calico.yaml!

sudo kubeadm init --pod-network-cidr=192.168.0.0/16

#Configure our account on the master to have admin access to the API server from a non-privileged account.

mkdir -p $HOME/.kube

sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

sudo chown $(id -u):$(id -g) $HOME/.kube/config

#Deploy yaml file for your pod network.

#This line of code has be updated since the publication of the course. 

kubectl apply -f calico.yaml

#Look for the all the system pods and calico pod to change to Running. 

#The DNS pod won't start until the Pod network is deployed and Running.

kubectl get pods --all-namespaces

#Gives you output over time, rather than repainting the screen on each iteration.

kubectl get pods --all-namespaces --watch

#All system pods should be Running

kubectl get pods --all-namespaces

#Get a list of our current nodes, just the master.

kubectl get nodes 

#Check out the systemd unit, and examine 10-kubeadm.conf

#Remeber the kubelet starts static pod manifests, and thus the core cluster pods

sudo systemctl status kubelet.service 

#check out the directory where the kubeconfig files live

ls /etc/kubernetes

#let's check out the manifests on the master

ls /etc/kubernetes/manifests

#And look more closely at API server and etcd's manifest.

sudo more /etc/kubernetes/manifests/etcd.yaml

sudo more /etc/kubernetes/manifests/kube-apiserver.yaml

Kubernetes package install from package manager

#Setup 

#   1. 3 VMs Ubuntu 16.04.5 or 18.04.1.0, 1 master, 2 nodes.

#   2. Static IPs on individual VMs

#   3. /etc/hosts hosts file includes name to IP mappings for VMs

#   4. Swap is disabled

#   5. Take snapshots prior to installations, this way you can install 

#       and revert to snapshot if needed

#Disable swap, swapoff then edit your fstab removing any entry for swap partitions

#You can recover the space with fdisk. You may want to reboot to ensure your config is ok. 

swapoff -a

vi /etc/fstab

#Add Google's apt repository gpg key

curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

#Add the Kubernetes apt repository

sudo bash -c 'cat <<EOF >/etc/apt/sources.list.d/kubernetes.list

deb https://apt.kubernetes.io/ kubernetes-xenial main

EOF'

#Update the package list and use apt-cache to inspect versions available in the repository

sudo apt-get update

apt-cache policy kubelet | head -n 20 

apt-cache policy docker.io | head -n 20 

#Install the required packages, if needed we can request a specific version

sudo apt-get install -y docker.io kubelet kubeadm kubectl

sudo apt-mark hold docker.io kubelet kubeadm kubectl

#Check the status of our kubelet and our container runtime, docker.

#The kubelet will enter a crashloop until it's joined. 

sudo systemctl status kubelet.service 

sudo systemctl status docker.service 

#Ensure both are set to start when the system starts up.

sudo systemctl enable kubelet.service

sudo systemctl enable docker.service

# Setup Docker daemon. This is a change that has been added since the recording of the course.

sudo bash -c 'cat > /etc/docker/daemon.json <<EOF

{

  "exec-opts": ["native.cgroupdriver=systemd"],

  "log-driver": "json-file",

  "log-opts": {

    "max-size": "100m"

  },

  "storage-driver": "overlay2"

}

EOF'

#Restart reload the systemd config and docker

sudo systemctl daemon-reload

sudo systemctl restart docker