Docker & Kubernetes - Ingress controller on AWS with Kops

In this post, using kops we'll make Kubernetes cluster and setup an Ingress controller on AWS.

Then, we are going to deploy a service of type ClusterIP and access it using the Ingress rule.

1. Create a S3 bucket to store our clusters state:

   $ aws s3 mb s3://clusters.dev.pykey.com
   



2. Export KOPS_STATE_STORE=s3://clusters.dev.pykey.com and then kops will use this location by default:

   $ export KOPS_STATE_STORE=s3://clusters.dev.pykey.com       
   



3. Create a cluster configuration. While the following command does NOT actually create the cloud resources it gives us an opportunity to review the configuration or change it:

   $ kops create cluster --zones=us-east-1a,us-east-1b,us-east-1c useast1.dev.pykey.com
   

   The kops create cluster command creates the configuration for our cluster (default conf creates 1 master and 2 worker nodes). Note that it only creates the configuration, it does not actually create the cloud resources - we'll do that in the next step with a kops update cluster.

   It prints commands we can use to explore further:



4. List clusters with: kops get cluster:
   

   $ kops get cluster --state s3://clusters.dev.pykey.com
   NAME			CLOUD	ZONES
   useast1.dev.pykey.com	aws	us-east-1a,us-east-1b,us-east-1c
   

   
   

   Or after setting export KOPS_STATE_STOR=s3://clusters.dev.pykey.com:

   $ kops get cluster
   NAME			CLOUD	ZONES
   useast1.dev.pykey.com	aws	us-east-1a,us-east-1b,us-east-1c
   



5. Edit this cluster with: kops edit cluster useast1.dev.pykey.com:
   

   # 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: kops.k8s.io/v1alpha2
   kind: Cluster
   metadata:
     creationTimestamp: "2020-09-03T21:24:06Z"
     name: useast1.dev.pykey.com
   spec:
     api:
       dns: {}
     authorization:
       rbac: {}
     channel: stable
     cloudProvider: aws
     configBase: s3://clusters.dev.pykey.com/useast1.dev.pykey.com
     containerRuntime: docker
     etcdClusters:
     - cpuRequest: 200m
       etcdMembers:
       - instanceGroup: master-us-east-1a
         name: a
       memoryRequest: 100Mi
       name: main
     - cpuRequest: 100m
       etcdMembers:
       - instanceGroup: master-us-east-1a
         name: a
       memoryRequest: 100Mi
       name: events
     iam:
       allowContainerRegistry: true
       legacy: false
     kubelet:
       anonymousAuth: false
     kubernetesApiAccess:
     - 0.0.0.0/0
     kubernetesVersion: 1.18.8
     masterInternalName: api.internal.useast1.dev.pykey.com
     masterPublicName: api.useast1.dev.pykey.com
     networkCIDR: 172.20.0.0/16
     networking:
       kubenet: {}
     nonMasqueradeCIDR: 100.64.0.0/10
     sshAccess:
     - 0.0.0.0/0
     subnets:
     - cidr: 172.20.32.0/19
       name: us-east-1a
       type: Public
       zone: us-east-1a
     - cidr: 172.20.64.0/19
       name: us-east-1b
       type: Public
       zone: us-east-1b
     - cidr: 172.20.96.0/19
       name: us-east-1c
       type: Public
       zone: us-east-1c
     topology:
       dns:
         type: Public
       masters: public
       nodes: public
   



6. Edit node instance group: kops edit ig --name=useast1.dev.pykey.com nodes:
   

   apiVersion: kops.k8s.io/v1alpha2
   kind: InstanceGroup
   metadata:
     creationTimestamp: "2020-09-01T23:17:45Z"
     labels:
       kops.k8s.io/cluster: useast1.dev.pykey.com
     name: nodes
   spec:
     image: 099720109477/ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-20200716
     machineType: t3.medium
     maxSize: 2
     minSize: 2
     nodeLabels:
       kops.k8s.io/instancegroup: nodes
     role: Node
     subnets:
     - us-east-1a
     - us-east-1b
     - us-east-1c      
   

   
   

   Modify it:

     machineType: t3.medium
     maxSize: 2
     minSize: 2
   =>
     machineType: t2.nano
     maxSize: 1
     minSize: 1    
   



7. Edit master instance group: kops edit ig --name=useast1.dev.pykey.com master-us-east-1a:
   

   apiVersion: kops.k8s.io/v1alpha2
   kind: InstanceGroup
   metadata:
     creationTimestamp: "2020-09-03T21:24:06Z"
     labels:
       kops.k8s.io/cluster: useast1.dev.pykey.com
     name: master-us-east-1a
   spec:
     image: 099720109477/ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-20200716
     machineType: t3.medium
     maxSize: 1
     minSize: 1
     nodeLabels:
       kops.k8s.io/instancegroup: master-us-east-1a
     role: Master
     subnets:
     - us-east-1a 
   

   
   


8. Finally configure cluster with: kops update cluster --name useast1.dev.pykey.com --yes
   See next item.


9. Run kops update cluster to preview what it is going to do our cluster in AWS:

   $ kops update cluster useast1.dev.pykey.com
   ...
   

   
   

   Now we'll use the same command, kops update cluster but with --yes to actually create the cluster:

   $ kops update cluster useast1.dev.pykey.com --yes 
   




10. Now that our cluster is ready, let's check:

    $ kops validate cluster
    Using cluster from kubectl context: useast1.dev.pykey.com
    
    Validating cluster useast1.dev.pykey.com
    
    INSTANCE GROUPS
    NAME			ROLE	MACHINETYPE	MIN	MAX	SUBNETS
    master-us-east-1a	Master	t3.medium	1	1	us-east-1a
    nodes			Node	t2.nano		1	1	us-east-1a,us-east-1b,us-east-1c
    
    NODE STATUS
    NAME				ROLE	READY
    ip-172-20-45-183.ec2.internal	master	True
    ip-172-20-95-112.ec2.internal	node	True
    
    Your cluster useast1.dev.pykey.com is ready
    



11. list nodes:

    $ kubectl get nodes 
    NAME                            STATUS   ROLES    AGE     VERSION
    ip-172-20-45-183.ec2.internal   Ready    master   11m     v1.18.8
    ip-172-20-95-112.ec2.internal   Ready    node     9m57s   v1.18.8        
    

Let's deploy the base components required for all Kubernetes cluster types. The deployment can be done using the following https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.27.0/deploy/static/mandatory.yaml:

apiVersion: v1
kind: Namespace
metadata:
  name: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: nginx-configuration
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: tcp-services
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
kind: ConfigMap
apiVersion: v1
metadata:
  name: udp-services
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nginx-ingress-serviceaccount
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: nginx-ingress-clusterrole
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
rules:
  - apiGroups:
      - ""
    resources:
      - configmaps
      - endpoints
      - nodes
      - pods
      - secrets
    verbs:
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - nodes
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - services
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - events
    verbs:
      - create
      - patch
  - apiGroups:
      - "extensions"
      - "networking.k8s.io"
    resources:
      - ingresses
    verbs:
      - get
      - list
      - watch
  - apiGroups:
      - "extensions"
      - "networking.k8s.io"
    resources:
      - ingresses/status
    verbs:
      - update

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: Role
metadata:
  name: nginx-ingress-role
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
rules:
  - apiGroups:
      - ""
    resources:
      - configmaps
      - pods
      - secrets
      - namespaces
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - configmaps
    resourceNames:
      # Defaults to "-"
      # Here: "-"
      # This has to be adapted if you change either parameter
      # when launching the nginx-ingress-controller.
      - "ingress-controller-leader-nginx"
    verbs:
      - get
      - update
  - apiGroups:
      - ""
    resources:
      - configmaps
    verbs:
      - create
  - apiGroups:
      - ""
    resources:
      - endpoints
    verbs:
      - get

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: RoleBinding
metadata:
  name: nginx-ingress-role-nisa-binding
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: nginx-ingress-role
subjects:
  - kind: ServiceAccount
    name: nginx-ingress-serviceaccount
    namespace: ingress-nginx

---
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: nginx-ingress-clusterrole-nisa-binding
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: nginx-ingress-clusterrole
subjects:
  - kind: ServiceAccount
    name: nginx-ingress-serviceaccount
    namespace: ingress-nginx

---

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-ingress-controller
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: ingress-nginx
      app.kubernetes.io/part-of: ingress-nginx
  template:
    metadata:
      labels:
        app.kubernetes.io/name: ingress-nginx
        app.kubernetes.io/part-of: ingress-nginx
      annotations:
        prometheus.io/port: "10254"
        prometheus.io/scrape: "true"
    spec:
      # wait up to five minutes for the drain of connections
      terminationGracePeriodSeconds: 300
      serviceAccountName: nginx-ingress-serviceaccount
      nodeSelector:
        kubernetes.io/os: linux
      containers:
        - name: nginx-ingress-controller
          image: quay.io/kubernetes-ingress-controller/nginx-ingress-controller:master
          args:
            - /nginx-ingress-controller
            - --configmap=$(POD_NAMESPACE)/nginx-configuration
            - --tcp-services-configmap=$(POD_NAMESPACE)/tcp-services
            - --udp-services-configmap=$(POD_NAMESPACE)/udp-services
            - --publish-service=$(POD_NAMESPACE)/ingress-nginx
            - --annotations-prefix=nginx.ingress.kubernetes.io
          securityContext:
            allowPrivilegeEscalation: true
            capabilities:
              drop:
                - ALL
              add:
                - NET_BIND_SERVICE
            # www-data -> 101
            runAsUser: 101
          env:
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: POD_NAMESPACE
              valueFrom:
                fieldRef:
                  fieldPath: metadata.namespace
          ports:
            - name: http
              containerPort: 80
              protocol: TCP
            - name: https
              containerPort: 443
              protocol: TCP
          livenessProbe:
            failureThreshold: 3
            httpGet:
              path: /healthz
              port: 10254
              scheme: HTTP
            initialDelaySeconds: 10
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 10
          readinessProbe:
            failureThreshold: 3
            httpGet:
              path: /healthz
              port: 10254
              scheme: HTTP
            periodSeconds: 10
            successThreshold: 1
            timeoutSeconds: 10
          lifecycle:
            preStop:
              exec:
                command:
                  - /wait-shutdown

---

apiVersion: v1
kind: LimitRange
metadata:
  name: ingress-nginx
  namespace: ingress-nginx
  labels:
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
spec:
  limits:
  - default:
    min:
      memory: 90Mi
      cpu: 100m
    type: Container    

To deploy it, use the following command:

$ kubectl apply --dry-run -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.27.0/deploy/static/mandatory.yaml
W0914 12:49:01.360238   33193 helpers.go:535] --dry-run is deprecated and can be replaced with --dry-run=client.
namespace/ingress-nginx created (dry run)
configmap/nginx-configuration created (dry run)
configmap/tcp-services created (dry run)
configmap/udp-services created (dry run)
serviceaccount/nginx-ingress-serviceaccount created (dry run)
clusterrole.rbac.authorization.k8s.io/nginx-ingress-clusterrole created (dry run)
role.rbac.authorization.k8s.io/nginx-ingress-role created (dry run)
rolebinding.rbac.authorization.k8s.io/nginx-ingress-role-nisa-binding created (dry run)
clusterrolebinding.rbac.authorization.k8s.io/nginx-ingress-clusterrole-nisa-binding created (dry run)
deployment.apps/nginx-ingress-controller created (dry run)
limitrange/ingress-nginx created (dry run)

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.27.0/deploy/static/mandatory.yaml
namespace/ingress-nginx created
configmap/nginx-configuration created
configmap/tcp-services created
configmap/udp-services created
serviceaccount/nginx-ingress-serviceaccount created
clusterrole.rbac.authorization.k8s.io/nginx-ingress-clusterrole created
role.rbac.authorization.k8s.io/nginx-ingress-role created
rolebinding.rbac.authorization.k8s.io/nginx-ingress-role-nisa-binding created
clusterrolebinding.rbac.authorization.k8s.io/nginx-ingress-clusterrole-nisa-binding created
deployment.apps/nginx-ingress-controller created
limitrange/ingress-nginx created

This deploys the biggest part of the whole infrastructure and thus creates a number of resources in the Kubernetes cluster.

We can watch the controller becoming available:

$ kubectl get pods --all-namespaces
NAMESPACE       NAME                                                    READY   STATUS    RESTARTS   AGE
ingress-nginx   nginx-ingress-controller-7fcb6cffc5-llmtb               1/1     Running   0          3m1s
kube-system     dns-controller-78f77977f-rt8bg                          1/1     Running   0          19m
kube-system     etcd-manager-events-ip-172-20-45-183.ec2.internal       1/1     Running   0          19m
kube-system     etcd-manager-main-ip-172-20-45-183.ec2.internal         1/1     Running   0          18m
kube-system     kops-controller-tckrf                                   1/1     Running   0          18m
kube-system     kube-apiserver-ip-172-20-45-183.ec2.internal            2/2     Running   0          18m
kube-system     kube-controller-manager-ip-172-20-45-183.ec2.internal   1/1     Running   0          19m
kube-system     kube-dns-64f86fb8dd-8xt5z                               3/3     Running   0          17m
kube-system     kube-dns-64f86fb8dd-p5s4v                               3/3     Running   0          19m
kube-system     kube-dns-autoscaler-cd7778b7b-n7pdm                     1/1     Running   0          19m
kube-system     kube-proxy-ip-172-20-45-183.ec2.internal                1/1     Running   0          19m
kube-system     kube-proxy-ip-172-20-95-112.ec2.internal                1/1     Running   0          17m
kube-system     kube-scheduler-ip-172-20-45-183.ec2.internal            1/1     Running   0          19m

The only missing piece is how the Ingress Controller will be exposed, in the generic case, this will be achieved by a service of type LoadBalancer. This is the last step in the deployment of the Ingress Controller:

$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/nginx-0.27.0/deploy/static/provider/cloud-generic.yaml
service/ingress-nginx created

Now, the LoadBalancer service will be deployed and receive the external IP address.

It might take Kubernetes a moment to request and assign an external IP to our service. To check the public IP, inspect the service in the ingress-nginx namespace:

$ kubectl get service -n ingress-nginx
NAME            TYPE           CLUSTER-IP       EXTERNAL-IP                                                               PORT(S)                      AGE
ingress-nginx   LoadBalancer   100.64.222.123   a832d3fd55ded41ed94294d7752206c0-1131297086.us-east-1.elb.amazonaws.com   80:31965/TCP,443:30676/TCP   82s

Once the EXTERNAL-IP is assigned, the NGINX Ingress Controller is ready to serve.

kind: Deployment
apiVersion: apps/v1
metadata:
  name: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx

  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: "nginxdemos/hello"
---
kind: Service
apiVersion: v1

metadata:
  name: nginx-demo
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
    - name: http
      port: 80
      targetPort: 80
      nodePort: 30008    

Deploy the pod and the service:

$ kubectl apply -f  demo-deploy.yaml 
deployment.apps/nginx created
service/nginx-demo created

$ kubectl get svc 
NAME         TYPE           CLUSTER-IP      EXTERNAL-IP                                                              PORT(S)        AGE
kubernetes   ClusterIP      100.64.0.1      <none>                                                                   443/TCP        121m
nginx-demo   LoadBalancer   100.71.139.63   a077ecbc0ac8249c99a1d7d139839d45-517528641.us-east-1.elb.amazonaws.com   80:30008/TCP   10m

The service named nginx-demo should be made available under the domain "dev.pykey.com". This would require an Ingress resource definition like the following:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: ingress-test
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - http:
      paths:
      - path:
        backend:
          serviceName: nginx-demo
          servicePort: 80    

Deploy the Ingress rule:

$ kubectl apply -f ingress.yaml 
ingress.extensions/ingress-test created    

Copy the EXTERNAL-IP of the nginx-demo service into the browser to verify:

To use a domain name instead of the LB address, we define a new record in Route53:

Now, we can use the domain name:

To delete our cluster:

$ kops delete cluster useast1.dev.pykey.com --yes

Delete S3 bucket:

$ aws s3 rb s3://clusters.dev.pykey.com    

1. NGINX Ingress Controller

Docker & K8s

1. Docker install on Amazon Linux AMI
2. Docker install on EC2 Ubuntu 14.04
3. Docker container vs Virtual Machine
4. Docker install on Ubuntu 14.04
5. Docker Hello World Application
6. Nginx image - share/copy files, Dockerfile
7. Working with Docker images : brief introduction
8. Docker image and container via docker commands (search, pull, run, ps, restart, attach, and rm)
9. More on docker run command (docker run -it, docker run --rm, etc.)
10. Docker Networks - Bridge Driver Network
11. Docker Persistent Storage
12. File sharing between host and container (docker run -d -p -v)
13. Linking containers and volume for datastore
14. Dockerfile - Build Docker images automatically I - FROM, MAINTAINER, and build context
15. Dockerfile - Build Docker images automatically II - revisiting FROM, MAINTAINER, build context, and caching
16. Dockerfile - Build Docker images automatically III - RUN
17. Dockerfile - Build Docker images automatically IV - CMD
18. Dockerfile - Build Docker images automatically V - WORKDIR, ENV, ADD, and ENTRYPOINT
19. Docker - Apache Tomcat
20. Docker - NodeJS
21. Docker - NodeJS with hostname
22. Docker Compose - NodeJS with MongoDB
23. Docker - Prometheus and Grafana with Docker-compose
24. Docker - StatsD/Graphite/Grafana
25. Docker - Deploying a Java EE JBoss/WildFly Application on AWS Elastic Beanstalk Using Docker Containers
26. Docker : NodeJS with GCP Kubernetes Engine
27. Docker : Jenkins Multibranch Pipeline with Jenkinsfile and Github
28. Docker : Jenkins Master and Slave
29. Docker - ELK : ElasticSearch, Logstash, and Kibana
30. Docker - ELK 7.6 : Elasticsearch on Centos 7
31. Docker - ELK 7.6 : Filebeat on Centos 7
32. Docker - ELK 7.6 : Logstash on Centos 7
33. Docker - ELK 7.6 : Kibana on Centos 7
34. Docker - ELK 7.6 : Elastic Stack with Docker Compose
35. Docker - Deploy Elastic Cloud on Kubernetes (ECK) via Elasticsearch operator on minikube
36. Docker - Deploy Elastic Stack via Helm on minikube
37. Docker Compose - A gentle introduction with WordPress
38. Docker Compose - MySQL
39. MEAN Stack app on Docker containers : micro services
40. MEAN Stack app on Docker containers : micro services via docker-compose
41. Docker Compose - Hashicorp's Vault and Consul Part A (install vault, unsealing, static secrets, and policies)
42. Docker Compose - Hashicorp's Vault and Consul Part B (EaaS, dynamic secrets, leases, and revocation)
43. Docker Compose - Hashicorp's Vault and Consul Part C (Consul)
44. Docker Compose with two containers - Flask REST API service container and an Apache server container
45. Docker compose : Nginx reverse proxy with multiple containers
46. Docker & Kubernetes : Envoy - Getting started
47. Docker & Kubernetes : Envoy - Front Proxy
48. Docker & Kubernetes : Ambassador - Envoy API Gateway on Kubernetes
49. Docker Packer
50. Docker Cheat Sheet
51. Docker Q & A #1
52. Kubernetes Q & A - Part I
53. Kubernetes Q & A - Part II
54. Docker - Run a React app in a docker
55. Docker - Run a React app in a docker II (snapshot app with nginx)
56. Docker - NodeJS and MySQL app with React in a docker
57. Docker - Step by Step NodeJS and MySQL app with React - I
58. Installing LAMP via puppet on Docker
59. Docker install via Puppet
60. Nginx Docker install via Ansible
61. Apache Hadoop CDH 5.8 Install with QuickStarts Docker
62. Docker - Deploying Flask app to ECS
63. Docker Compose - Deploying WordPress to AWS
64. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI EC2 type)
65. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI Fargate type)
66. Docker - ECS Fargate
67. Docker - AWS ECS service discovery with Flask and Redis
68. Docker & Kubernetes : minikube
69. Docker & Kubernetes 2 : minikube Django with Postgres - persistent volume
70. Docker & Kubernetes 3 : minikube Django with Redis and Celery
71. Docker & Kubernetes 4 : Django with RDS via AWS Kops
72. Docker & Kubernetes : Kops on AWS
73. Docker & Kubernetes : Ingress controller on AWS with Kops
74. Docker & Kubernetes : HashiCorp's Vault and Consul on minikube
75. Docker & Kubernetes : HashiCorp's Vault and Consul - Auto-unseal using Transit Secrets Engine
76. Docker & Kubernetes : Persistent Volumes & Persistent Volumes Claims - hostPath and annotations
77. Docker & Kubernetes : Persistent Volumes - Dynamic volume provisioning
78. Docker & Kubernetes : DaemonSet
79. Docker & Kubernetes : Secrets
80. Docker & Kubernetes : kubectl command
81. Docker & Kubernetes : Assign a Kubernetes Pod to a particular node in a Kubernetes cluster
82. Docker & Kubernetes : Configure a Pod to Use a ConfigMap
83. AWS : EKS (Elastic Container Service for Kubernetes)
84. Docker & Kubernetes : Run a React app in a minikube
85. Docker & Kubernetes : Minikube install on AWS EC2
86. Docker & Kubernetes : Cassandra with a StatefulSet
87. Docker & Kubernetes : Terraform and AWS EKS
88. Docker & Kubernetes : Pods and Service definitions
89. Docker & Kubernetes : Service IP and the Service Type
90. Docker & Kubernetes : Kubernetes DNS with Pods and Services
91. Docker & Kubernetes : Headless service and discovering pods
92. Docker & Kubernetes : Scaling and Updating application
93. Docker & Kubernetes : Horizontal pod autoscaler on minikubes
94. Docker & Kubernetes : From a monolithic app to micro services on GCP Kubernetes
95. Docker & Kubernetes : Rolling updates
96. Docker & Kubernetes : Deployments to GKE (Rolling update, Canary and Blue-green deployments)
97. Docker & Kubernetes : Slack Chat Bot with NodeJS on GCP Kubernetes
98. Docker & Kubernetes : Continuous Delivery with Jenkins Multibranch Pipeline for Dev, Canary, and Production Environments on GCP Kubernetes
99. Docker & Kubernetes : NodePort vs LoadBalancer vs Ingress
100. Docker & Kubernetes : MongoDB / MongoExpress on Minikube
101. Docker & Kubernetes : Load Testing with Locust on GCP Kubernetes
102. Docker & Kubernetes : MongoDB with StatefulSets on GCP Kubernetes Engine
103. Docker & Kubernetes : Nginx Ingress Controller on Minikube
104. Docker & Kubernetes : Setting up Ingress with NGINX Controller on Minikube (Mac)
105. Docker & Kubernetes : Nginx Ingress Controller for Dashboard service on Minikube
106. Docker & Kubernetes : Nginx Ingress Controller on GCP Kubernetes
107. Docker & Kubernetes : Kubernetes Ingress with AWS ALB Ingress Controller in EKS
108. Docker & Kubernetes : Setting up a private cluster on GCP Kubernetes
109. Docker & Kubernetes : Kubernetes Namespaces (default, kube-public, kube-system) and switching namespaces (kubens)
110. Docker & Kubernetes : StatefulSets on minikube
111. Docker & Kubernetes : RBAC
112. Docker & Kubernetes Service Account, RBAC, and IAM
113. Docker & Kubernetes - Kubernetes Service Account, RBAC, IAM with EKS ALB, Part 1
114. Docker & Kubernetes : Helm Chart
115. Docker & Kubernetes : My first Helm deploy
116. Docker & Kubernetes : Readiness and Liveness Probes
117. Docker & Kubernetes : Helm chart repository with Github pages
118. Docker & Kubernetes : Deploying WordPress and MariaDB with Ingress to Minikube using Helm Chart
119. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 2 Chart
120. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 3 Chart
121. Docker & Kubernetes : Helm Chart for Node/Express and MySQL with Ingress
122. Docker & Kubernetes : Deploy Prometheus and Grafana using Helm and Prometheus Operator - Monitoring Kubernetes node resources out of the box
123. Docker & Kubernetes : Deploy Prometheus and Grafana using kube-prometheus-stack Helm Chart
124. Docker & Kubernetes : Istio (service mesh) sidecar proxy on GCP Kubernetes
125. Docker & Kubernetes : Istio on EKS
126. Docker & Kubernetes : Istio on Minikube with AWS EC2 for Bookinfo Application
127. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part I)
128. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part II - Prometheus, Grafana, pin a service, split traffic, and inject faults)
129. Docker & Kubernetes : Helm Package Manager with MySQL on GCP Kubernetes Engine
130. Docker & Kubernetes : Deploying Memcached on Kubernetes Engine
131. Docker & Kubernetes : EKS Control Plane (API server) Metrics with Prometheus
132. Docker & Kubernetes : Spinnaker on EKS with Halyard
133. Docker & Kubernetes : Continuous Delivery Pipelines with Spinnaker and Kubernetes Engine
134. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-dind (docker-in-docker)
135. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-kind (k8s-in-docker)
136. Docker & Kubernetes : nodeSelector, nodeAffinity, taints/tolerations, pod affinity and anti-affinity - Assigning Pods to Nodes
137. Docker & Kubernetes : Jenkins-X on EKS
138. Docker & Kubernetes : ArgoCD App of Apps with Heml on Kubernetes
139. Docker & Kubernetes : ArgoCD on Kubernetes cluster
140. Docker & Kubernetes : GitOps with ArgoCD for Continuous Delivery to Kubernetes clusters (minikube) - guestbook