Custom Resource Definition (CRDs)

Custom Resource Definition (CRD) is an extension mechanism that allows users to define custom resources and their schema in a Kubernetes cluster. It enables the Kubernetes API server to understand and handle new resource types beyond the built-in resources like pods, services, deployments, etc.

Why CRDs are Used:

1. Extensibility: Kubernetes provides a set of core resources, but every application may have specific requirements that cannot be fully expressed using the built-in resources. CRDs enable you to extend the Kubernetes API to handle custom resources tailored to your application.
2. Declarative Configuration: CRDs enable you to define and manage your application's resources declaratively. You can use YAML or JSON files to specify the desired state of your custom resources, and Kubernetes controllers will work to ensure that the actual state matches the desired state.
3. Consistency Across Clusters: By defining custom resources with CRDs, you can maintain consistency across multiple Kubernetes clusters. The same custom resources and their controllers can be deployed to different clusters, providing a uniform way to manage applications.
4. Operators and Automation: CRDs are often used in conjunction with controllers to create Operators. Operators are automation controllers that extend the Kubernetes API to manage applications and their components in a more intelligent and automated way.

Example of a CRD:

Let's say you have a distributed application that requires a set of resources specific to its architecture. You can define a CRD to represent a custom resource called 'MyApp' with specific properties. Below is an illustrative example:

Step 1: Define the CRD (e.g. myapp-crd.yaml):

apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: myapps.example.com
spec:
  group: example.com
  names:
    kind: MyApp
    plural: myapps
    singular: myapp
  scope: Namespaced
  version: v1alpha1
  additionalPrinterColumns:
  - JSONPath: .spec.version
    name: Version
    type: string
  - JSONPath: .spec.size
    name: Size
    type: string
  - JSONPath: .status.nodes
    name: Nodes
    type: integer
  validation:
    openAPIV3Schema:
      type: object
      properties:
        spec:
          type: object
          properties:
            version:
              type: string
            size:
              type: string
            nodes:
              type: integer        

In this example, we define a CRD named 'myapps.example.com'. It specifies the properties of the custom resource, such as the API group, version, and the schema for the custom resource.

Step 2: Use the Custom Resource (e.g. myapp-instance.yaml):

apiVersion: example.com/v1alpha1
kind: MyApp
metadata:
  name: myapp-instance
spec:
  version: "1.0"
  size: "Medium"        

In this example, we create an instance of the 'MyApp' custom resource named 'myapp-instance'. It specifies the desired state of the custom resource using the properties defined in the CRD.

Applying CRD and Custom Resource:

# Apply the CRD
kubectl apply -f myapp-crd.yaml

# Apply the Custom Resource
kubectl apply -f myapp-instance.yaml

# Check the status of the custom resource
kubectl get myapps        

Custom Resources and CRDs provide a powerful abstraction for extending and customizing Kubernetes to suit the needs of diverse applications. They enable users to manage application-specific resources using the same familiar Kubernetes API and tooling.