Replication Controllers

A replication controller ensures that a specified number of replicas of a pod are running at all times. If pods exit or are deleted, the replica controller acts to instantiate more up to the desired number. Likewise, if there are more running than desired, it deletes as many as necessary to match the number.

The definition of a replication controller consists mainly of:

  1. The number of replicas desired (which can be adjusted at runtime).

  2. A pod definition for creating a replicated pod.

  3. A selector for identifying managed pods.

The selector is just a set of labels that all of the pods managed by the replication controller should have. So that set of labels is included in the pod definition that the replication controller instantiates. This selector is used by the replication controller to determine how many instances of the pod are already running in order to adjust as needed.

It is not the job of the replication controller to perform auto-scaling based on load or traffic, as it does not track either; rather, this would require its replica count to be adjusted by an external auto-scaler.

Replication controllers are a core Kubernetes object, ReplicationController. The Kubernetes documentation has more details on replication controllers.

Here is an example ReplicationController definition with some omissions and callouts:

apiVersion: v1
kind: ReplicationController
  name: frontend-1
  replicas: 1  (1)
  selector:    (2)
    name: frontend
  template:    (3)
      labels:  (4)
        name: frontend (5)
      - image: openshift/hello-openshift
        name: helloworld
        - containerPort: 8080
          protocol: TCP
      restartPolicy: Always
  1. The number of copies of the pod to run.

  2. The label selector of the pod to run.

  3. A template for the pod the controller creates.

  4. Labels on the pod should include those from the label selector.

  5. The maximum name length after expanding any parameters is 63 characters.

Deployments and Deployment Configurations

Building on replication controllers, OpenShift adds expanded support for the software development and deployment lifecycle with the concept of deployments. In the simplest case, a deployment just creates a new replication controller and lets it start up pods. However, OpenShift deployments also provide the ability to transition from an existing deployment of an image to a new one and also define hooks to be run before or after creating the replication controller.

The OpenShift DeploymentConfiguration object defines the following details of a deployment:

  1. The elements of a ReplicationController definition.

  2. Triggers for creating a new deployment automatically.

  3. The strategy for transitioning between deployments.

  4. Life cycle hooks.

Each time a deployment is triggered, whether manually or automatically, a deployer pod manages the deployment (including scaling down the old replication controller, scaling up the new one, and running hooks). The deployment pod remains for an indefinite amount of time after it completes the deployment in order to retain its logs of the deployment. When a deployment is superseded by another, the previous replication controller is retained to enable easy rollback if needed.

For detailed instructions on how to create and interact with deployments, refer to Deployments.

Here is an example DeploymentConfiguration definition with some omissions and callouts:

apiVersion: v1
kind: DeploymentConfig
  name: frontend
  replicas: 5
    name: frontend
  template: { ... }
  - type: ConfigChange (1)
  - imageChangeParams:
      automatic: true
      - helloworld
        kind: ImageStreamTag
        name: hello-openshift:latest
    type: ImageChange  (2)
    type: Rolling      (3)
  1. A ConfigChange trigger causes a new deployment to be created any time the replication controller template changes.

  2. An ImageChange trigger causes a new deployment to be created each time a new version of the backing image is available in the named image stream.

  3. The default Rolling strategy makes a downtime-free transition between deployments.