Skip to main content

Kubernetes: 2. Replica Set

Replication Controller

  • Replication Controller is a Kubernetes Controller
  • Runs multiple instances of kubernetes pods in a cluster thus providing high availability
  • Replication Controller and Replica Set have same functionality but they are different
  • Replication Controller is the older way to scale the pods
  • Selector labels is optional, if you dont specify then ".spec.template.metadata.labels" is defaulted

Replica Set
  • Replica Set is also Kubernetes Controller
  • Replica Set are for having the desired number of Pods running, same as Replication Controller
  • Kubernetes keeps a watch of the number of pods that should be running at any time and automatically creates/deletes based on the pods running
  • What differentiates a Replica Set from Replication Controller is selector with set-based label requirements.
    • Set based allow filtering keys according to a set of values.
    • Three kinds of operators are supported:
      • in
      • notin
      • exists
Updating Replica Set
  • Use kubectl edit rs <rs-name> and modify the replica set
  • After this delete all the pods, so that the replica set creates new pods based on the updated definition file
  • Note that the replica set does not propagate the updated changes into pods definition files
  • If we use kubectl edit pod <pod-name>, changes are reflected in Pod immediately
  • Similarly the changes for replicaSet are reflected in the definition file but not in the underlying resources created by the replicaSet, so if you update the number of replicas then the changes are instantaneously updated
  • Alternatively delete the replicaSet and re-create it with updated configuration
  • Deleting a replica-set automatically deletes the pod underlying it. So new pods are created when replicaSet is created

Scale the Replica Set
  • Use kubectl edit rs <rs-name> and modify the replica set
  • Changes in the file will be immediately reflected, this is because replica set now looks at the new number of replicas to be maintained
  • So it will add or delete the pods automatically
  • Alternatively use kubectl scale --replicas=<no-of-replicas> replicaset <replica-set-name>

replication-controller-definition.yaml
apiVersion: v1
kind: ReplicationController
metadata:
    name: myapp-rc
    labels:
        app: myapp
        type: front-end

spec:
    template:
        metadata:
            name: myapp-pod
            labels:
                app: myapp
                type: front-end
        spec:
            containers:
            - name: nginx-container
              image: nginx


    replicas: 3


kubectl create -f replication-controller-definition.yaml

kubectl get replicationcontroller


replica-set-definition.yaml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
    name: myapp-rs
    labels:
        app: myapp
        type: front-end

spec:
    template:
        metadata:
            name: myapp-pod
            labels:
                app: myapp
                type: front-end
        spec:
            containers:
            - name: nginx-container
              image: nginx


    replicas: 3
    selector:
        matchLabels:
            type: front-end

kubectl create -f replica-set-definition.yaml

kubectl get replicaset

kubectl delete replicaset myapp-rs
-> Deletes the underlying pods as well

kubectl replace -f replica-set-definition.yaml
-> Manually update the yaml definition file and run the REPLACE command

kubectl scale --replicas=6 -f replica-set-definition.yaml
-> Using file name to update the replica set will not update the YAML efinition file

kubectl scale --replicas=6 replicaset myapp-rs


selector:
matchExpressions:
- {key: tier, operator: In, values: [frontend1]}

Comments

Popular posts from this blog

Kubernetes: 6. Imperative Commands

Imperative commands are useful in quickly creating the resources on Kubernetes kubectl --dry-run -> When created with this option, Kubernetes just validates the definition and does not actually create the resource -o=yaml -> Gets the output in YAML format kubectl run nginx-pod --image=nginx:alpine  -> Create a pod with name nginx-pod and image nginx:alpine kubectl run httpd --image=httpd:alpine  -> By default, run implies run-a-pod kubectl run redis --image=redis:alpine --labels=tier=db  -> Create a pod with name redis and image redis:alpine and labels set to tier=db kubectl run custom-nginx --image=nginx --port=8080  -> Create a pod with name custom-nginx and image nginx to run on port 8080 kubectl expose pod redis --port=6379 --name=redis-service  -> Create a service with name redis-service to expose pod named redis on service-port 6379 kubectl create deployment webapp --image=kodekloud/webapp-color --replicas=3  -> Create a depl...

Kubernetes: 21. Secrets

Passwords In the webapps we store the properties file for storing and retrieving the data required by application But we never store the application passwords, truststore, keystore passwords etc here We might store them in an encrypted format, but storing them as plain text is not the correct way In Kubernetes we store these sensitive information in Secrets https://medium.com/avmconsulting-blog/secrets-management-in-kubernetes-378cbf8171d0 Secrets Secrets are used to store the sensitive information They are similar to ConfigMaps, except that they are stored in hashed or encoded format Note that they are only encoded (using base64) but are not encrypted So secrets are a safe option to store sensitive information but infact they are not the safest option As such secret objects should be not checked into source code tools, its best to store them encrypted at REST in ETCD Again as in ConfigMaps, we have to create the secrets object first and then inject them into the pods There are 2 ways ...

Kubernetes: 19. Configure Application

Configuring application consists of Configuring commands and arguments on applications Configuring environment variables Configuring secrets Docker Commands docker run ubuntu  -> Runs ubuntu container and exit, container CMD is set to [bash], so the container quitely exits docker run ubuntu echo "Hello World" -> Runs ubuntu container, prints "Hello World" exits quitely. To update the default settings, create your own image from the base image lets call this ubuntu-sleeper image FROM ubuntu CMD sleep 5 CMD can also be mentioned in the JSON format like CMD ["sleep", "5"] Note that with JSON format the first element should always be the command to execute,  for eg, it CANNOT be ["sleep 5"] Run build the new ubuntu-sleeper image and run the new image docker build -t ubuntu-sleeper .  -> Build the image docker run ubuntu-sleeper -> Run the new image So the new image will launch ubuntu container, sleep for 5 seconds and quitely ex...