cdk8s+ (cdk8s-plus)

The connections property on a Pod provides a high-level API to automatically manage Network Policies. Using allowTo or allowFrom creates both egress and ingress rules on both ends of the connection to ensure traffic is permitted in both directions.

By default, calling these methods applies isolation to both the source and the destination pods. If you need to change this behavior, use the isolation option with one of the following values:

• PodConnectionsIsolation.POD: Only applies isolation (egress rules) to the pod calling the method.
• PodConnectionsIsolation.PEER: Only applies isolation (ingress rules) to the peer pod.
• (Default) Both sides are isolated.

import * as k from 'cdk8s';
import * as kplus from 'cdk8s-plus-34';

const app = new k.App();
const chart = new k.Chart(app, 'Chart');

const redis = new kplus.Pod(chart, 'Redis', {
  containers: [{ image: 'redis', portNumber: 6379 }]
});
const web = new kplus.Pod(chart, 'Web', {
  containers: [{ image: 'web' }]
});

// Automatically configures network policies for both pods
web.connections.allowTo(redis);
// OR
redis.connections.allowFrom(web);

The HorizontalPodAutoscaler supports several types of metrics via the kplus.Metric class:

• Resource Metrics: Scale based on cluster resources like CPU or memory. Note that resource usage is summed across all containers in a pod, which may not reflect individual container pressure.
• Pods Metrics: Scale based on a metric describing each pod in the target (e.g., requests-per-second). Requires a labelSelector.
• Container Metrics: Scale based on a specific container's metric within the target pods.
• Object Metrics: Scale based on a metric describing a single Kubernetes object (e.g., an Ingress).
• External Metrics: Scale based on metrics not associated with any Kubernetes object (e.g., an SQS queue).

// Resource CPU
kplus.Metric.resourceCpu(kplus.MetricTarget.averageUtilization(70))

// Pods Metrics
kplus.Metric.pods({
  name: 'requests-per-second',
  target: kplus.MetricTarget.averageUtilization(50),
  labelSelector: kplus.LabelSelector.of({ labels: { app: 'scraper' } }),
})

// Container Memory
kplus.Metric.containerMemory(kplus.MetricTarget.value(4096))

// Object Metrics
kplus.Metric.object({
  object: ingress,
  name: 'requests-per-second',
  target: kplus.MetricTarget.averageUtilization(50),
})

// External Metrics
kplus.Metric.external({
  labelSelector: kplus.LabelSelector.of({ labels: { app: 'scraper' } }),
  name: 'sqs-queue',
  target: kplus.MetricTarget.averageUtilization(50),
})

The storageClassName property determines how the backing volume is provisioned.

• Default behavior: If storageClassName is not set, Kubernetes will either use the cluster's default storage class for dynamic provisioning or look for a pre-existing volume that has no storage class assigned.
• Explicit Storage Class: Provide a string (e.g., 'large-ebs') to request a specific storage class. Kubernetes will then attempt to locate an existing volume with that class or provision a new one using the appropriate provisioner.
• Disable Dynamic Provisioning: Pass an empty string "" to storageClassName. This ensures the volume is not assigned to any storage class, effectively disabling dynamic provisioning and requiring a pre-existing volume.

// Explicit storage class
const claim = new kplus.PersistentVolumeClaim(chart, 'Claim', {
  storage: cdk8s.Size.gibibytes(50),
  storageClassName: 'large-ebs',
});

// Disable dynamic provisioning
const claim = new kplus.PersistentVolumeClaim(chart, 'Claim', {
  storage: cdk8s.Size.gibibytes(50),
  storageClassName: "",
});

You can use the ttlAfterFinished property in the Job constructor to automatically clean up a Job after it has finished its execution successfully. This property accepts a Duration object. This is useful for ad-hoc provisioning tasks or one-off processing jobs to prevent stale Job resources from accumulating in your cluster.

import * as kplus from 'cdk8s-plus-34';
import { Construct } from 'constructs';
import { App, Chart, ChartProps, Duration } from 'cdk8s';

export class MyChart extends Chart {
  constructor(scope: Construct, id: string, props: ChartProps = { }) {
    super(scope, id, props);

    // let's define a job spec, and set a 1 second TTL.
    const job = new kplus.Job(this, 'LoadData', {
      ttlAfterFinished: Duration.seconds(1)
    });

    // now add a container to all the pods created by this job
    job.addContainer({
      image: 'loader'
    });
  }
}

const app = new App();
new MyChart(app, 'Job');
app.synth();

When using StatefulSet, you can define volumeClaimTemplates to provide stable, persistent storage for each pod. Each pod in the set receives its own unique PersistentVolumeClaim (e.g., name-statefulset-0).

To use these templates:

1. Define the templates in the StatefulSet constructor via volumeClaimTemplates or using the addVolumeClaimTemplate method.
2. Reference the volumes in your container's volumeMounts using Volume.fromName(chart, templateName, volumeName).

import * as kplus from 'cdk8s-plus-32';
import { Size } from 'cdk8s';

// Reference a volume defined in a template
const dataVolume = Volume.fromName(chart, "pvc-template-data", "data-volume")

// Create a StatefulSet with PVC templates
const statefulSet = new kplus.StatefulSet(this, 'StatefulSet', {
  containers: [{
    image: 'nginx',
    volumeMounts: [{
      volume: dataVolume,
      path: '/data',
    }, {
      volume: Volume.fromName(chart, "pvc-template-temp", "temp-volume"),
      path: '/data',
    }],
  }],
  volumeClaimTemplates: [{
    name: dataVolume.name,
    storage: Size.gibibytes(10),
    accessModes: [kplus.PersistentVolumeAccessMode.READ_WRITE_ONCE],
    storageClassName: 'standard',
  }, {
    name: 'temp-volume',
    storage: Size.gibibytes(10),
    accessModes: [kplus.PersistentVolumeAccessMode.READ_WRITE_ONCE],
    storageClassName: 'standard',
  }],
});

// Or add PVC templates after creation
statefulSet.addVolumeClaimTemplate({
  name: 'logs-volume',
  storage: Size.gibibytes(5),
  accessModes: [kplus.PersistentVolumeAccessMode.READ_WRITE_ONCE],
});