Initial commit

Author: sayems

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+.DS_Store

Dockerfile

@@ -0,0 +1,4 @@
+# Just for demo purposes obviously
+FROM httpd:2.4-alpine
+
+COPY ./index.html /usr/local/apache2/htdocs/

LICENSE

@@ -0,0 +1,86 @@
+# Kubernetes Tutorial 
+My kubernetes examples for Developers. A collection of how to work with Kubernetes and Docker.
+
+ 
+
+## **Contents**
+
+01. **[Prerequisites](#prerequisites)**
+02. **[Installation](#minikube)**
+	- [Setup Kubernetes on Local Machine](#minikube)
+	- [Setup Kubernetes with Vagrant and Virtualbox](https://github.com/sayems/kubernetes.examples/blob/master/vagrant.md#kubernetes-with-vagrant-and-virtualbox)	
+	- [Setup Google Kubernetes Engine](https://cloud.google.com/kubernetes-engine/)
+	- [Setup Kubernetes on AWS](https://kubernetes.io/docs/getting-started-guides/aws/)
+03. **[Dashboard](#kubernetes-dashboard)**
+04. **[Useful Commands](#useful-commands)**
+05. **[Resources](#resources)**
+	- [Courses](#courses)
+	- [Books](#books)
+	- [Cheat Sheet](https://github.com/sayems/kubernetes.examples/blob/master/cheat-sheet.md#kubernetes-cheat-sheet)
+
+ 
+
+![](https://github.com/sayems/kubernetes.examples/blob/master/images/kubernetes.png)
+
+ 
+
+## Prerequisites
+- Basic Linux command line skills
+- Experience with using Docker
+- Familiarity with YAML is also a plus
+
+ 
+
+## Minikube
+The simplest and quickest way to get started with Kubernetes is to install [Minikube](https://kubernetes.io/docs/getting-started-guides/minikube/) on your local machine. Minikube is a tool that sets up a single-node cluster that's great for both testing Kubernetes and developing apps locally.
+
+- [macOS](https://github.com/sayems/kubernetes.examples/blob/master/mac.md#requirements)
+- [Linux](https://github.com/sayems/kubernetes.examples/blob/master/linux.md#requirements)
+- [Windows](https://github.com/sayems/kubernetes.examples/blob/master/windows.md#requirements)
+
+Since Minikube is running locally instead of on a cloud provider, certain provider-specific features like LoadBalancers and PersistentVolumes will not work out-of-the-box. However, you can use NodePort LoadBalancers and HostPath PersistentVolumes.
+
+
+**NOTE** Minikube doesn't support ```LoadBalancer``` services, so the service will never get an external IP. But you get the IP and port through which you can access service by running ```minikube service kubia-http```.
+
+ 
+
+### Kubernetes Dashboard
+
+![](https://github.com/sayems/kubernetes.examples/blob/master/images/dashboard.png)
+
+To open the dashboard in your browser when using Minikube to run your Kubernetes cluster, run the following command:
+
+```
+$ minikube dashboard
+```
+The dashboard will open in your default browser. Unlike with GKE, you won’t need to enter any credentials to access it.
+
+ 
+
+## Useful Commands
+
+| Command | Description |
+| --- | --- |
+| `kubectl get pods` | List all pods in ps output format. |
+| `kubectl get pods -o wide` | List all pods in ps output format with more information (such as node name) |
+| `kubectl get replicationcontroller web` | List a single replication controller with specified NAME in ps output format. |
+| `kubectl get -o json pod web-pod-13je7` | List a single pod in JSON output format. |
+| `kubectl get -f pod.ya ml -o json` | List a pod identified by type and name specified in “pod.ya ml” in JSON output format. |
+| `kubectl get -o template pod/web-pod-13je7 --template=` | Return only the phase value of the specified pod. |
+| `kubectl get rc,services` | List all replication controllers and services together in ps output format. |
+| `kubectl get rc/web service/frontend pods/web-pod-13je7` | List one or more resources by their type and names. |
+
+ 
+
+## Resources
+There are a lot of helpful Kubernetes resources on the internet. This is a short list of my favorites courses and books!
+
+### Courses
+
+- [Scalable Microservices with Kubernetes](https://www.udacity.com/course/scalable-microservices-with-kubernetes--ud615)
+
+
+### Books
+
+- [Kubernetes in Action](https://www.manning.com/books/kubernetes-in-action)

README.md

@@ -0,0 +1,71 @@
+# Kubernetes Cheat Sheet
+
+This is a small [Kubernetes Cheat Sheet](https://kubernetes.io/docs/reference/kubectl/cheatsheet/) with the list of commands and settings I use, almost on a daily basis, when working with kubernetes.
+
+ 
+
+### Cluster Introspection
+
+| Command | Description |
+| --- | --- |
+| `kubectl get services`                            | List all services               |
+| `kubectl get pods`                                | List all pods                   |
+| `kubectl get nodes -w`                            | Watch nodes continuously        |
+| `kubectl version`                                 | Get version information         |
+| `kubectl cluster-info`                            | Get cluster information         |
+| `kubectl config view`                             | Get the configuration           |
+| `kubectl describe node <node>`                    | Output information about a node |
+
+
+### Pod and Container Introspection
+
+| Command | Description |
+| --- | --- |
+| `kubectl get pods`                          | List the current pods                           |
+| `kubectl describe pod <name>`               | Describe pod <name>                             |
+| `kubectl get rc`                            | List the replication controllers                |
+| `kubectl get rc --namespace="<namespace>"`  | List the replication controllers in <namespace> |
+| `ubectl describe rc <name>`                 | Describe replication controller <name>          |
+| `kubectl get svc`                           | List the services                               |
+| `kubectl describe svc <name>`               | Describe service <name>                         |
+
+
+### Interacting with Pods
+
+| Command | Description |
+| --- | --- |
+| `kubectl run <name> --image=<image-name>` 						              	| `Launch a pod called <name> using image <image-name>` |
+| `kubectl create -f <manifest.yaml>` 									                | `Create a service described in <manifest.yaml>` |
+| `kubectl scale --replicas=<count> rc <name>` 						            	| `Scale replication controller <name> to <count> instances` |
+| `kubectl expose rc <name> --port=<external> --target-port=<internal>` | `Map port <external> to port <internal> on replication controller <name>` |
+
+### Stopping Kubernetes
+
+| Command | Description |
+| --- | --- |
+| `kubectl delete pod <name>`                                           | Delete pod <name>                    |
+| `kubectl delete rc <name>`                                            | Delete replication controller <name> |
+| `kubectl delete svc <name>`                                           | Delete service <name>                |
+| `kubectl drain <n> --delete-local-data --force --ignore-daemonsets `  | Stop all pods on <n>                 |
+| `kubectl delete node <name>`                                          | Remove <node> from the cluster       |
+
+### Debugging
+
+| Command | Description |
+| --- | --- |
+| `kubectl exec <service> <command> [-c <$container>]`  | execute <command> on <service>, optionally selecting container <$container> |
+| `kubectl logs -f <name> [-c <$container>]`            | Get logs from service <name>, optionally selecting container <$container>   |
+| `watch -n 2 cat /var/log/kublet.log`                  | Watch the Kublet logs                                                       |
+| `kubectl top node`                                    | Show metrics for nodes                                                      |
+| `kubectl top pod`                                     | Show metrics for pods                                                       |
+
+### Administration
+
+| Command | Description |
+| --- | --- |
+| `kubeadm init`                                              | Initialize your master node               |
+| `kubeadm join --token <token> <master-ip>:<master-port>`    | Join a node to your Kubernetes cluster    |
+| `kubectl create namespace <namespace>`                      | Create namespace <name>                   |
+| `kubectl taint nodes --all node-role.kubernetes.io/master-` | Allow Kubernetes master nodes to run pods |
+| `kubeadm reset`                                             | Reset current state                       |
+| `kubectl get secrets`                                       | List all secrets                          |

cheat-sheet.md

@@ -0,0 +1 @@
+Hello world!

images/dashboard.png

@@ -0,0 +1 @@
+## Requirement

images/kubernetes.png

@@ -0,0 +1,125 @@
+# Requirements
+
+Minikube requires that VT-x/AMD-v virtualization is enabled in BIOS. To check that this is enabled on OSX / macOS run:
+
+    sysctl -a | grep machdep.cpu.features | grep VMX
+
+If there's output, you're good!
+
+# Prerequisites
+
+- kubectl
+- docker (for Mac)
+- minikube
+- virtualbox
+
+```
+brew update && brew install kubectl && brew cask install docker minikube virtualbox
+```
+
+# Verify
+
+    docker --version                # Docker version 17.09.0-ce, build afdb6d4
+    docker-compose --version        # docker-compose version 1.16.1, build 6d1ac21
+    docker-machine --version        # docker-machine version 0.12.2, build 9371605
+    minikube version                # minikube version: v0.22.3
+    kubectl version --client        # Client Version: version.Info{Major:"1", Minor:"8", GitVersion:"v1.8.1", GitCommit:"f38e43b221d08850172a9a4ea785a86a3ffa3b3a", GitTreeState:"clean", BuildDate:"2017-10-12T00:45:05Z", GoVersion:"go1.9.1", Compiler:"gc", Platform:"darwin/amd64"}      
+    
+# Start
+
+    minikube start
+    
+This can take a while, expected output:
+
+    Starting local Kubernetes cluster...
+    Kubectl is now configured to use the cluster.
+
+Great! You now have a running Kubernetes cluster locally. Minikube started a virtual machine for you, and a Kubernetes cluster is now running in that VM.
+
+# Check k8s
+
+    kubectl get nodes
+    
+Should output something like:
+
+    NAME       STATUS    ROLES     AGE       VERSION
+    minikube   Ready     <none>    40s       v1.7.5
+    
+# Use minikube's built-in docker daemon:
+
+    eval $(minikube docker-env)
+    
+Running `docker ps` should now output something like:
+
+```
+CONTAINER ID        IMAGE                                         COMMAND                 CREATED             STATUS              PORTS               NAMES
+e97128790bf9        gcr.io/google-containers/kube-addon-manager   "/opt/kube-addons.sh"   22 seconds ago      Up 22 seconds                           k8s_kube-addon-manager_kube-addon-manager-minikube_kube-system_c654b2f084cf26941c334a2c3d6db53d_0
+69707e54d1d0        gcr.io/google_containers/pause-amd64:3.0      "/pause"                33 seconds ago      Up 33 seconds                           k8s_POD_kube-addon-manager-minikube_kube-system_c654b2f084cf26941c334a2c3d6db53d_0
+```
+
+# Build, deploy and run an image on your local k8s setup
+
+First setup a local registry, so Kubernetes can pull the image(s) from there:
+
+    docker run -d -p 5000:5000 --restart=always --name registry registry:2
+
+## Build
+
+First of, store all files (Dockerfile, my-app.yml, index.html) in this gist locally in some new (empty) directory.
+
+You can build the Dockerfile below locally if you want to follow this guide to the letter. Store the Dockerfile locally, preferably in an empty directory and run:
+
+    docker build . --tag my-app
+    
+You should now have an image named 'my-app' locally, check by using `docker images` (or your own image of course). You can then publish it to your local docker registry:
+
+    docker tag my-app localhost:5000/my-app:0.1.0
+    
+Running `docker images` should now output the following:
+
+```
+REPOSITORY                                             TAG                 IMAGE ID            CREATED             SIZE
+my-app                                                 latest              cc949ad8c8d3        44 seconds ago      89.3MB
+localhost:5000/my-app                                  0.1.0               cc949ad8c8d3        44 seconds ago      89.3MB
+httpd                                                  2.4-alpine          fe26194c0b94        7 days ago          89.3MB
+```
+
+## Deploy and run
+
+Store the file below `my-app.yml` on your system and run the following:
+
+    kubectl create -f my-app.yml
+    
+You should now see your pod and your service:
+
+    kubectl get all
+
+The configuration exposes `my-app` outside of the cluster, you can get the address to access it by running:
+
+    minikube service my-app --url
+    
+This should give an output like `http://192.168.99.100:30304` (the port will most likely differ). Go there with your favorite browser, you should see "Hello world!". You just accessed your application from outside of your local Kubernetes cluster!
+    
+# Kubernetes GUI
+
+    minikube dashboard
+    
+# Delete deployment of my-app
+
+    kubectl delete deploy my-app
+    kubectl delete service my-app
+    
+You're now good to go and deploy other images!
+
+# Reset everything
+
+    minikube stop;
+    minikube delete;
+    rm -rf ~/.minikube .kube;
+    brew uninstall kubectl;
+    brew cask uninstall docker virtualbox minikube;
+
+# Version
+
+Last tested on 2017 October 20th 
+macOS Sierra 10.12.6

index.html

@@ -0,0 +1,43 @@
+# APP DEPLOYMENT
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  labels:
+    run: my-app
+  name: my-app
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      run: my-app-exposed
+  template:
+    metadata:
+      labels:
+        run: my-app-exposed
+    spec:
+      containers:
+      - image: localhost:5000/my-app:0.1.0
+        name: my-app
+        ports:
+        - containerPort: 80
+          protocol: TCP
+
+---
+
+# APP SERVICE
+
+apiVersion: v1
+kind: Service
+metadata:
+  labels:
+    run: my-app
+  name: my-app
+spec:
+  ports:
+  - port: 80
+    protocol: TCP
+    targetPort: 80
+  selector:
+    run: my-app-exposed
+  type: NodePort