function-auto-ready

This composition function automatically detects composed resources that are ready. It considers a composed resource ready if:

• Another function added the composed resource to the desired state.
• The composed resource appears in the observed state (i.e. it exists).
• For standard Kubernetes resources with health check implementations (see list below), the resource passes resource-specific health checks.
• For all other resources (Crossplane managed resources, custom resources, etc.), the composed resource has the status condition type: Ready, status: True.

Crossplane considers a composite resource (XR) to be ready when all of its desired composed resources are ready.

Health Checks

This function implements resource-specific health checks for standard Kubernetes resources. The following table shows the current implementation status:

Core (core/v1)

• Pod - Succeeded, or Running with Ready condition (RestartPolicy: Always)
• Service - ClusterIP/NodePort: immediately ready; LoadBalancer: requires ingress assignment
• Namespace - Always ready if it exists
• Node
• ConfigMap - Always ready if it exists
• Secret - Always ready if it exists
• ServiceAccount - Always ready if it exists
• Endpoints
• PersistentVolume
• PersistentVolumeClaim - Phase is Bound
• ReplicationController
• ResourceQuota
• LimitRange
• Event

Apps (apps/v1)

• Deployment - spec.replicas == status.availableReplicas, all replicas updated, Available condition is True
• StatefulSet - spec.replicas == status.readyReplicas, all replicas at current revision
• DaemonSet - All desired pods are scheduled, ready, updated, and available
• ReplicaSet - Observed generation matches, available replicas match desired, no replica failures

Batch (batch/v1)

• Job - Complete condition is True (not Failed or Suspended)
• CronJob - Suspended, has active jobs, or last execution succeeded

Autoscaling (autoscaling/v2)

• HorizontalPodAutoscaler - ScalingActive or ScalingLimited, no failed conditions

Networking (networking.k8s.io/v1)

• Ingress - Load balancer ingress is assigned
• IngressClass
• NetworkPolicy

RBAC (rbac.authorization.k8s.io/v1)

• Role
• ClusterRole
• RoleBinding
• ClusterRoleBinding

Storage (storage.k8s.io/v1)

• StorageClass
• VolumeAttachment
• CSIDriver
• CSINode

Policy (policy/v1)

• PodDisruptionBudget

For all other resource types (Crossplane managed resources, custom resources, etc.), the function falls back to checking the standard Ready status condition.

In this example, the Go Templating function is used to add a desired composed resource - an Amazon Web Services S3 Bucket. Once Crossplane has created the Bucket, the Auto Ready function will let Crossplane know when it is ready. Because this XR only has one composed resource, the XR will become ready when the Bucket becomes ready.

apiVersion: apiextensions.crossplane.io/v1
kind: Composition
metadata:
  name: example
spec:
  compositeTypeRef:
    apiVersion: example.crossplane.io/v1beta1
    kind: XR
  mode: Pipeline
  pipeline:
  - step: create-a-bucket
    functionRef:
      name: function-go-templating
    input:
      apiVersion: gotemplating.fn.crossplane.io/v1beta1
      kind: GoTemplate
      source: Inline
      inline:
        template: |
          apiVersion: s3.aws.upbound.io/v1beta1
          kind: Bucket
          metadata:
            annotations:
              gotemplating.fn.crossplane.io/composition-resource-name: bucket
          spec:
            forProvider:
              region: {{ .observed.composite.resource.spec.region }}
  - step: automatically-detect-ready-composed-resources
    functionRef:
      name: function-auto-ready

See the example directory for an example you can run locally using the Crossplane CLI:

$ crossplane render xr.yaml composition.yaml functions.yaml

To test with observed resources (simulating resources that already exist):

$ crossplane render xr.yaml composition-k8s.yaml functions.yaml -o observed-k8s.yaml

See the composition functions documentation to learn more about crossplane render.

Developing this function

This function uses Go, Docker, and the Crossplane CLI to build functions.

# Run code generation - see input/generate.go
$ go generate ./...

# Run tests - see fn_test.go
$ go test ./...

# Build the function's runtime image - see Dockerfile
$ docker build . --tag=runtime

# Build a function package - see package/crossplane.yaml
$ crossplane xpkg build -f package --embed-runtime-image=runtime