CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-io-fabric8--openshift-client

Java client library for OpenShift REST APIs, providing fluent DSL access to OpenShift resources and operations.

—

Pending
Overview
Eval results
Files

machine-management.mddocs/

Machine and Node Management

Machine lifecycle management and node configuration through machine.openshift.io and machineconfiguration.openshift.io API groups. Provides comprehensive control over cluster nodes, machine pools, and runtime configuration.

Capabilities

Machine API Management

OpenShift Machine API for managing the lifecycle of cluster nodes and machine resources.

/**
 * Access to Machine API Group (machine.openshift.io)
 * Machine lifecycle and cluster node management
 */
OpenShiftMachineAPIGroupDSL machine();

interface OpenShiftMachineAPIGroupDSL {
    /** Individual machine resources (v1beta1) */
    MixedOperation<Machine, MachineList, Resource<Machine>> machines();
    
    /** Machine set resources for grouped machine management (v1beta1) */
    MixedOperation<MachineSet, MachineSetList, Resource<MachineSet>> machineSets();
    
    /** Machine health monitoring and remediation (v1beta1) */
    MixedOperation<MachineHealthCheck, MachineHealthCheckList, Resource<MachineHealthCheck>> machineHealthChecks();
    
    /** Control plane machine sets (v1) */
    NonNamespaceOperation<ControlPlaneMachineSet, ControlPlaneMachineSetList, Resource<ControlPlaneMachineSet>> controlPlaneMachineSets();
}

Usage Examples:

// List all machines in cluster
MachineList machines = client.machine().machines()
    .inNamespace("openshift-machine-api")
    .list();

// Get specific machine details
Machine machine = client.machine().machines()
    .inNamespace("openshift-machine-api")
    .withName("my-cluster-worker-us-east-1a-abc123")
    .get();

if (machine != null) {
    String phase = machine.getStatus().getPhase();
    String nodeName = machine.getStatus().getNodeRef().getName();
    System.out.println("Machine " + nodeName + " is " + phase);
}

// Scale machine set
MachineSet machineSet = client.machine().machineSets()
    .inNamespace("openshift-machine-api")
    .withName("my-cluster-worker-us-east-1a")
    .get();

if (machineSet != null) {
    machineSet.getSpec().setReplicas(5);
    client.machine().machineSets()
        .inNamespace("openshift-machine-api")
        .replace(machineSet);
}

// Create machine health check
MachineHealthCheck healthCheck = new MachineHealthCheckBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("worker-health-check")
        .withNamespace("openshift-machine-api")
        .build())
    .withSpec(new MachineHealthCheckSpecBuilder()
        .withSelector(new LabelSelectorBuilder()
            .addToMatchLabels("machine.openshift.io/cluster-api-machine-role", "worker")
            .build())
        .withUnhealthyConditions(
            new UnhealthyConditionBuilder()
                .withType("Ready")
                .withStatus("False")
                .withTimeout("5m")
                .build(),
            new UnhealthyConditionBuilder()
                .withType("Ready")
                .withStatus("Unknown")
                .withTimeout("5m")
                .build())
        .withMaxUnhealthy("40%")
        .withNodeStartupTimeout("10m")
        .build())
    .build();

client.machine().machineHealthChecks()
    .inNamespace("openshift-machine-api")
    .create(healthCheck);

Machine Configuration Management

Machine configuration management for node-level settings, container runtime, and kubelet configuration.

/**
 * Access to Machine Configuration API Group (machineconfiguration.openshift.io/v1)
 * Node configuration and runtime management
 */
MachineConfigurationAPIGroupDSL machineConfigurations();

interface MachineConfigurationAPIGroupDSL {
    /** Individual machine configurations */
    NonNamespaceOperation<MachineConfig, MachineConfigList, Resource<MachineConfig>> machineConfigs();
    
    /** Machine configuration pools for grouped node management */
    NonNamespaceOperation<MachineConfigPool, MachineConfigPoolList, Resource<MachineConfigPool>> machineConfigPools();
    
    /** Kubelet configuration settings */
    NonNamespaceOperation<KubeletConfig, KubeletConfigList, Resource<KubeletConfig>> kubeletConfigs();
    
    /** Container runtime configuration */
    NonNamespaceOperation<ContainerRuntimeConfig, ContainerRuntimeConfigList, Resource<ContainerRuntimeConfig>> containerRuntimeConfigs();
    
    /** Machine config controller configuration */
    NonNamespaceOperation<ControllerConfig, ControllerConfigList, Resource<ControllerConfig>> controllerConfigs();
}

Usage Examples:

// List machine config pools
MachineConfigPoolList pools = client.machineConfigurations().machineConfigPools().list();

// Get worker pool status
MachineConfigPool workerPool = client.machineConfigurations().machineConfigPools()
    .withName("worker")
    .get();

if (workerPool != null) {
    int readyMachines = workerPool.getStatus().getReadyMachineCount();
    int totalMachines = workerPool.getStatus().getMachineCount();
    boolean updated = workerPool.getStatus().getConditions().stream()
        .anyMatch(c -> "Updated".equals(c.getType()) && "True".equals(c.getStatus()));
    
    System.out.println("Worker pool: " + readyMachines + "/" + totalMachines + " ready, updated: " + updated);
}

// Create custom kubelet configuration
KubeletConfig kubeletConfig = new KubeletConfigBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("custom-kubelet")
        .build())
    .withSpec(new KubeletConfigSpecBuilder()
        .withMachineConfigPoolSelector(new LabelSelectorBuilder()
            .addToMatchLabels("pools.operator.machineconfiguration.openshift.io/worker", "")
            .build())
        .withKubeletConfig(new ObjectNode(JsonNodeFactory.instance)
            .put("maxPods", 500)
            .put("podsPerCore", 0))
        .build())
    .build();

client.machineConfigurations().kubeletConfigs().create(kubeletConfig);

// Create container runtime configuration  
ContainerRuntimeConfig runtimeConfig = new ContainerRuntimeConfigBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("custom-crio")
        .build())
    .withSpec(new ContainerRuntimeConfigSpecBuilder()
        .withMachineConfigPoolSelector(new LabelSelectorBuilder()
            .addToMatchLabels("pools.operator.machineconfiguration.openshift.io/worker", "")
            .build())
        .withContainerRuntimeConfig(new ContainerRuntimeConfigurationBuilder()
            .withPidsLimit(4096L)
            .build())
        .build())
    .build();

client.machineConfigurations().containerRuntimeConfigs().create(runtimeConfig);

Autoscaling Management

Machine-level autoscaling configuration for dynamic cluster scaling based on workload demands.

/**
 * Access to OpenShift Autoscaling API Group (autoscaling.openshift.io)
 * Cluster and machine autoscaling capabilities
 */
OpenShiftAutoscalingAPIGroupDSL openShiftAutoscaling();

interface OpenShiftAutoscalingAPIGroupDSL {
    /** v1 autoscaling API access */
    V1AutoscalingAPIGroupDSL v1();
    
    /** v1beta1 autoscaling API access */
    V1beta1AutoscalingAPIGroupDSL v1beta1();
}

interface V1AutoscalingAPIGroupDSL {
    /** Cluster-wide autoscaling configuration */
    NonNamespaceOperation<ClusterAutoscaler, ClusterAutoscalerList, Resource<ClusterAutoscaler>> clusterAutoscalers();
}

interface V1beta1AutoscalingAPIGroupDSL {
    /** Machine-level autoscaling configuration */
    MixedOperation<MachineAutoscaler, MachineAutoscalerList, Resource<MachineAutoscaler>> machineAutoscalers();
}

Usage Examples:

// Configure cluster autoscaler
ClusterAutoscaler clusterAutoscaler = new ClusterAutoscalerBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("default")
        .build())
    .withSpec(new ClusterAutoscalerSpecBuilder()
        .withPodPriorityThreshold(-10)
        .withResourceLimits(new ResourceLimitsBuilder()
            .withMaxNodesTotal(100)
            .withCores(new ResourceRangeBuilder().withMin(8).withMax(400).build())
            .withMemory(new ResourceRangeBuilder().withMin(4).withMax(1600).build())
            .build())
        .withScaleDown(new ScaleDownConfigBuilder()
            .withEnabled(true)
            .withDelayAfterAdd("10m")
            .withDelayAfterDelete("10s")
            .withDelayAfterFailure("3m")
            .withUnneededTime("10m")
            .build())
        .build())
    .build();

client.openShiftAutoscaling().v1().clusterAutoscalers().createOrReplace(clusterAutoscaler);

// Configure machine set autoscaling
MachineAutoscaler machineAutoscaler = new MachineAutoscalerBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("worker-us-east-1a")
        .withNamespace("openshift-machine-api")
        .build())
    .withSpec(new MachineAutoscalerSpecBuilder()
        .withMinReplicas(1)
        .withMaxReplicas(10)
        .withScaleTargetRef(new CrossVersionObjectReferenceBuilder()
            .withApiVersion("machine.openshift.io/v1beta1")
            .withKind("MachineSet")
            .withName("my-cluster-worker-us-east-1a")
            .build())
        .build())
    .build();

client.openShiftAutoscaling().v1beta1().machineAutoscalers()
    .inNamespace("openshift-machine-api")
    .create(machineAutoscaler);

Usage Patterns

Node Maintenance and Updates

// Cordon and drain node for maintenance
Machine machine = client.machine().machines()
    .inNamespace("openshift-machine-api")
    .withName("my-cluster-worker-abc123")
    .get();

if (machine != null) {
    String nodeName = machine.getStatus().getNodeRef().getName();
    
    // Cordon the node
    Node node = client.nodes().withName(nodeName).get();
    node.getSpec().setUnschedulable(true);
    client.nodes().withName(nodeName).replace(node);
    
    // Delete machine to trigger replacement
    client.machine().machines()
        .inNamespace("openshift-machine-api")
        .withName("my-cluster-worker-abc123")
        .delete();
}

Machine Configuration Updates

// Create machine config for custom files
MachineConfig customConfig = new MachineConfigBuilder()
    .withMetadata(new ObjectMetaBuilder()
        .withName("99-custom-config")
        .withLabels(Map.of(
            "machineconfiguration.openshift.io/role", "worker"
        ))
        .build())
    .withSpec(new MachineConfigSpecBuilder()
        .withConfig(new IgnitionBuilder()
            .withVersion("3.1.0")
            .withStorage(new StorageBuilder()
                .addNewFile()
                    .withPath("/etc/custom-app.conf")
                    .withMode(420) // 0644
                    .withContents(new ContentsBuilder()
                        .withSource("data:text/plain;base64,Y3VzdG9tIGNvbmZpZw==")
                        .build())
                .endFile()
                .build())
            .build())
        .build())
    .build();

client.machineConfigurations().machineConfigs().create(customConfig);

Install with Tessl CLI

npx tessl i tessl/maven-io-fabric8--openshift-client

docs

client-setup.md

configuration-management.md

core-resources.md

index.md

machine-management.md

monitoring.md

multicluster-management.md

operator-management.md

security-rbac.md

tile.json