Deployments, finally we have reached to the last major object in Kubernetes. Deployments take everything we have being doing so far and encapusaltes it. What I mean is the following:

Of course you can have more than 1 pod in replica set. Yes, it is replica set when under Deployment, not replication controller. But the purpose is the same.

So let's create our Deployment now:

To create a deployment again we have two ways:

• Iterative - With kubectl create and so on
• Declarative - Using YML / JSON file, I will be using this one.

As I am bored with the iterative way, let's clean our env and create a deployment. I won't delete my service as I will use it later.

First, let's create our YML file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-deploy
spec:
  replicas: 10
  selector:
    matchLabels:
      app: hello-date
  template:
    metadata:
      labels:
        app: hello-date
    spec:
      containers:
      - name: hello-pod
        image: andonovj/httpserverdemo:latest
        ports:
        - containerPort: 1234

Bare in mind that the deployment have been moved from extensions/v1beta1 → apps/v1 and forward :) Also a little syntax changes compared to the old one, but nothing serious.

Once we have the YAML file, we can continue as follows:

ubuntu@k8s-master:~$ kubectl create -f deploy.yml
deployment.apps/hello-deploy created
ubuntu@k8s-master:~$ kubectl  get deploy

NAME           READY   UP-TO-DATE   AVAILABLE   AGE
hello-deploy   1/10    10           1           26s
ubuntu@k8s-master:~$ kubectl describe deploy

Name:                   hello-deploy
Namespace:              default
CreationTimestamp:      Sat, 02 May 2020 15:54:34 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=hello-date
Replicas:               10 desired | 10 updated | 10 total | 10 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=hello-date
  Containers:
   hello-pod:
    Image:        andonovj/httpserverdemo:latest
    Port:         1234/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   hello-deploy-6cd458494 (10/10 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  8m59s  deployment-controller  Scaled up replica set hello-deploy-6cd458494 to 10

Again, we can check if our app is working:

As already mentioned, deployments operate with Replicat Sets, NOT replication Controllers. Eventhough that is a new objects, it inherits a lot of stuff from the replication controller. You can check the Replica sets, almost the same as the replication controller and notice that we don't have Replication Controllers anymore…after I have deleted them in the past of course.

ubuntu@k8s-master:~$ kubectl get rs
NAME                     DESIRED   CURRENT   READY   AGE
hello-deploy-6cd458494   10        10        10      11m
ubuntu@k8s-master:~$ kubectl get rc
No resources found in default namespace.
ubuntu@k8s-master:~$ kubectl describe rs
Name:           hello-deploy-6cd458494
Namespace:      default
Selector:       app=hello-date,pod-template-hash=6cd458494
Labels:         app=hello-date
                pod-template-hash=6cd458494
Annotations:    deployment.kubernetes.io/desired-replicas: 10
                deployment.kubernetes.io/max-replicas: 13
                deployment.kubernetes.io/revision: 1
Controlled By:  Deployment/hello-deploy
Replicas:       10 current / 10 desired
Pods Status:    10 Running / 0 Waiting / 0 Succeeded / 0 Failed
Pod Template:
  Labels:  app=hello-date
           pod-template-hash=6cd458494
  Containers:
   hello-pod:
    Image:        andonovj/httpserverdemo:latest
    Port:         1234/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Events:
  Type    Reason            Age   From                   Message
  ----    ------            ----  ----                   -------
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-mjtw9
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-m9bgx
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-44jvs
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-6v8lt
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-zwh4l
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-jf594
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-vd7mt
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-nq2wx
  Normal  SuccessfulCreate  16m   replicaset-controller  Created pod: hello-deploy-6cd458494-f8j5f
  Normal  SuccessfulCreate  16m   replicaset-controller  (combined from similar events): Created pod: hello-deploy-6cd458494-dxqh7
 
ubuntu@k8s-master:~$ kubectl get rc
No resources found in default namespace.                     <- We don't have Replication Controllers anymore.

Now, we have deployed application, which is totally scalable and redundancy is provided as Hell :) But what if want to fix couple bugs, or present new version.

What we do then ?

Well, let's edit our application, let's add “v2” into our awesome app:

namespace HttpServerDemo
{
    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading.Tasks;
    using System.IO;
    using System.Threading;

    class Program
    {
        public async static Task Main(string[] args)
        {
            TcpListener tcpListener = new TcpListener(IPAddress.Any, 1234);
            tcpListener.Start();

            while (true)
            {
                TcpClient tcpClient = await tcpListener.AcceptTcpClientAsync();
                await ProcessClientAsync(tcpClient);

            }
        }

        public static async Task ProcessClientAsync(TcpClient tcpClient)
        {
            const string NewLine = "\r\n";
            using (var networkStream = tcpClient.GetStream())
            {
                byte[] requestBytes = new byte[1000000];   //TODO USE Buffer
                int bytesRead = await networkStream.ReadAsync(requestBytes, 0, requestBytes.Length);
                string request = Encoding.UTF8.GetString(requestBytes, 0, bytesRead);
                string responseText = @"<h1>Working... v2</h1>" +
                                          $"<form> <h1> Time is: {System.DateTime.Now} </h1> </form>";
                string response = "HTTP/1.1 200 OK" + NewLine
                                 + "Server: SoftuniServer/1.0 " + NewLine
                                 + "Content-Type: text/html" + NewLine
                                 + "Content-Length: " + responseText.Length + NewLine + NewLine
                                 + responseText;

                byte[] responseBytes = Encoding.UTF8.GetBytes(response);
                await networkStream.WriteAsync(responseBytes, 0, responseBytes.Length);
                Console.WriteLine(request);
                Console.WriteLine(new string('=', 60));
            }
        }
    }
}

You see that “v2” after “Working”, yes, I just added it now. Let's rebuild via docker, upload it and edit our edition to v2 :) The Rebuild part you can see in the Docker section, but I will put the output here as well: