tessl/npm-pulumi--kubernetes

A comprehensive Pulumi resource provider for creating and managing Kubernetes resources and workloads in a running cluster

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

@pulumi/kubernetes

Name: tessl/npm-pulumi--kubernetes
Author: tessl

The Pulumi Kubernetes provider enables declarative management of Kubernetes resources using familiar programming languages. This provider offers comprehensive coverage of the Kubernetes API with type-safe resource management, advanced deployment abstractions, and seamless integration with the Pulumi ecosystem.

Package Information

Package Name: @pulumi/kubernetes
Package Type: npm
Language: TypeScript
Version: 4.23.0
License: Apache-2.0
Installation: npm install @pulumi/kubernetes
Repository: pulumi/pulumi-kubernetes

Core Imports

Basic Provider Import

import * as kubernetes from "@pulumi/kubernetes";
import * as k8s from "@pulumi/kubernetes"; // Common alias

API Group Imports

// Core resources (Pod, Service, ConfigMap, etc.)
import { core } from "@pulumi/kubernetes";

// Workload resources (Deployment, StatefulSet, etc.)
import { apps } from "@pulumi/kubernetes";

// Networking resources (Ingress, NetworkPolicy, etc.)
import { networking } from "@pulumi/kubernetes";

// RBAC resources (Role, ClusterRole, etc.)
import { rbac } from "@pulumi/kubernetes";

// Storage resources (StorageClass, PersistentVolume, etc.)
import { storage } from "@pulumi/kubernetes";

// Special capabilities
import { helm, yaml, kustomize } from "@pulumi/kubernetes";

Provider Class Import

import { Provider, ProviderArgs } from "@pulumi/kubernetes";

Basic Usage

Quick Start Example

import * as k8s from "@pulumi/kubernetes";

// Create a deployment
const deployment = new k8s.apps.v1.Deployment("nginx", {
    spec: {
        replicas: 3,
        selector: {
            matchLabels: { app: "nginx" },
        },
        template: {
            metadata: {
                labels: { app: "nginx" },
            },
            spec: {
                containers: [{
                    name: "nginx",
                    image: "nginx:1.21",
                    ports: [{ containerPort: 80 }],
                }],
            },
        },
    },
});

// Create a service to expose the deployment
const service = new k8s.core.v1.Service("nginx-service", {
    spec: {
        selector: { app: "nginx" },
        ports: [{ port: 80, targetPort: 80 }],
        type: "LoadBalancer",
    },
});

Using YAML Manifests

import * as k8s from "@pulumi/kubernetes";

// Deploy from YAML files
const app = new k8s.yaml.v2.ConfigFile("app", {
    files: ["./k8s-manifests.yaml"],
});

Using Helm Charts

import * as k8s from "@pulumi/kubernetes";

// Deploy a Helm chart
const chart = new k8s.helm.v4.Chart("nginx", {
    chart: "nginx",
    repositoryOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        replicaCount: 3,
        service: { type: "LoadBalancer" },
    },
});

Architecture

The @pulumi/kubernetes package provides comprehensive access to the Kubernetes API through several key components:

Resource Coverage

166+ Kubernetes resource types across 24 API groups
Complete type system with strongly-typed input/output interfaces
Resource variants including standard, List, and Patch operations
Multiple API versions with automatic deprecation handling

Provider System

Flexible authentication supporting kubeconfig, service accounts, and cloud providers
Advanced features like server-side apply, resource transformations, and custom timeouts
Multi-cluster support with provider instances and configuration inheritance

Deployment Abstractions

Native Resources: Direct Kubernetes API resource management
YAML Integration: Deploy existing manifests with Pulumi orchestration
Helm Charts: Full Helm ecosystem integration without Tiller
Kustomize: Native Kustomize directory processing

Capabilities

Core Kubernetes Resources

Fundamental Kubernetes resources for basic cluster operations including workload management, configuration, storage, and networking.

// Essential resource constructors
class Pod extends pulumi.CustomResource {
    constructor(name: string, args: PodArgs, opts?: pulumi.ResourceOptions);
}

class Service extends pulumi.CustomResource {
    constructor(name: string, args: ServiceArgs, opts?: pulumi.ResourceOptions);
}

class ConfigMap extends pulumi.CustomResource {
    constructor(name: string, args: ConfigMapArgs, opts?: pulumi.ResourceOptions);
}

class Secret extends pulumi.CustomResource {
    constructor(name: string, args: SecretArgs, opts?: pulumi.ResourceOptions);
}

Key Resources: Pod, Service, ConfigMap, Secret, Namespace, PersistentVolume, PersistentVolumeClaim, ServiceAccount, Endpoints, Event, LimitRange, Node, PodTemplate, ReplicationController, ResourceQuota

Core Resources Documentation

Application Workload Resources

High-level controllers for managing scalable applications, batch processing, and daemon processes across the cluster.

// Workload management resources
class Deployment extends pulumi.CustomResource {
    constructor(name: string, args: DeploymentArgs, opts?: pulumi.ResourceOptions);
}

class StatefulSet extends pulumi.CustomResource {
    constructor(name: string, args: StatefulSetArgs, opts?: pulumi.ResourceOptions);
}

class Job extends pulumi.CustomResource {
    constructor(name: string, args: JobArgs, opts?: pulumi.ResourceOptions);
}

class CronJob extends pulumi.CustomResource {
    constructor(name: string, args: CronJobArgs, opts?: pulumi.ResourceOptions);
}

Key Resources: Deployment, StatefulSet, DaemonSet, ReplicaSet, Job, CronJob, ControllerRevision

Workload Resources Documentation

Networking Resources

Network traffic management, ingress routing, and connectivity policies for secure and scalable cluster networking.

// Network management resources
class Ingress extends pulumi.CustomResource {
    constructor(name: string, args: IngressArgs, opts?: pulumi.ResourceOptions);
}

class NetworkPolicy extends pulumi.CustomResource {
    constructor(name: string, args: NetworkPolicyArgs, opts?: pulumi.ResourceOptions);
}

class IngressClass extends pulumi.CustomResource {
    constructor(name: string, args: IngressClassArgs, opts?: pulumi.ResourceOptions);
}

Key Resources: Ingress, NetworkPolicy, IngressClass, IPAddress, ServiceCIDR, ClusterCIDR

Networking Resources Documentation

Storage Resources

Dynamic volume provisioning, storage class management, and Container Storage Interface (CSI) driver integration.

// Storage management resources
class StorageClass extends pulumi.CustomResource {
    constructor(name: string, args: StorageClassArgs, opts?: pulumi.ResourceOptions);
}

class VolumeAttachment extends pulumi.CustomResource {
    constructor(name: string, args: VolumeAttachmentArgs, opts?: pulumi.ResourceOptions);
}

class CSIDriver extends pulumi.CustomResource {
    constructor(name: string, args: CSIDriverArgs, opts?: pulumi.ResourceOptions);
}

Key Resources: StorageClass, VolumeAttachment, CSIDriver, CSINode, CSIStorageCapacity, VolumeAttributesClass

Storage Resources Documentation

RBAC Security Resources

Role-based access control for cluster security, authentication, and authorization management.

// Security and access control resources
class Role extends pulumi.CustomResource {
    constructor(name: string, args: RoleArgs, opts?: pulumi.ResourceOptions);
}

class RoleBinding extends pulumi.CustomResource {
    constructor(name: string, args: RoleBindingArgs, opts?: pulumi.ResourceOptions);
}

class ClusterRole extends pulumi.CustomResource {
    constructor(name: string, args: ClusterRoleArgs, opts?: pulumi.ResourceOptions);
}

class ClusterRoleBinding extends pulumi.CustomResource {
    constructor(name: string, args: ClusterRoleBindingArgs, opts?: pulumi.ResourceOptions);
}

Key Resources: Role, RoleBinding, ClusterRole, ClusterRoleBinding

RBAC Resources Documentation

Helm Chart Integration

Deploy and manage Helm charts as Pulumi resources with full lifecycle management and value customization.

// Helm Chart v4 (recommended)
class Chart extends pulumi.ComponentResource {
    constructor(name: string, args: ChartArgs, opts?: pulumi.ComponentResourceOptions);
}

// Helm Release v3 (legacy)
class Release extends pulumi.CustomResource {
    constructor(name: string, args: ReleaseArgs, opts?: pulumi.ResourceOptions);
}

interface ChartArgs {
    chart: pulumi.Input<string>;
    version?: pulumi.Input<string>;
    values?: pulumi.Input<any>;
    repositoryOpts?: pulumi.Input<RepositoryOptsArgs>;
    fetchOpts?: pulumi.Input<FetchOptsArgs>;
}

Helm Integration Documentation

YAML Manifest Deployment

Deploy Kubernetes resources from existing YAML files and directories with full Pulumi integration and transformation support.

// YAML ConfigFile for single files
class ConfigFile extends pulumi.ComponentResource {
    constructor(name: string, args: ConfigFileArgs, opts?: pulumi.ComponentResourceOptions);
}

// YAML ConfigGroup for multiple files
class ConfigGroup extends pulumi.ComponentResource {
    constructor(name: string, args: ConfigGroupArgs, opts?: pulumi.ComponentResourceOptions);
}

interface ConfigFileArgs {
    files: pulumi.Input<string[]>;
    transformations?: ((o: any, opts: pulumi.CustomResourceOptions) => void)[];
    resourcePrefix?: pulumi.Input<string>;
}

YAML Deployment Documentation

Kustomize Integration

Deploy applications using Kustomize directory configurations with full customization and multi-environment support.

// Kustomize Directory processing
class Directory extends pulumi.ComponentResource {
    constructor(name: string, args: DirectoryArgs, opts?: pulumi.ComponentResourceOptions);
}

interface DirectoryArgs {
    directory: pulumi.Input<string>;
    transformations?: ((o: any, opts: pulumi.CustomResourceOptions) => void)[];
    resourcePrefix?: pulumi.Input<string>;
}

Kustomize Integration Documentation

Provider Configuration

Configure Kubernetes cluster connections, authentication, and advanced provider features for production deployments.

class Provider extends pulumi.ProviderResource {
    constructor(name: string, args?: ProviderArgs, opts?: pulumi.ResourceOptions);
}

interface ProviderArgs {
    kubeconfig?: pulumi.Input<string>;
    context?: pulumi.Input<string>;
    cluster?: pulumi.Input<string>;
    namespace?: pulumi.Input<string>;
    enableServerSideApply?: pulumi.Input<boolean>;
    enableConfigMapMutable?: pulumi.Input<boolean>;
    deleteUnreachable?: pulumi.Input<boolean>;
    helmReleaseSettings?: pulumi.Input<HelmReleaseSettings>;
    kubeClientSettings?: pulumi.Input<KubeClientSettings>;
}

Provider Configuration Documentation

Type System

The package provides comprehensive TypeScript definitions with:

Input Types: Strongly-typed resource arguments with Pulumi Input wrappers
Output Types: Resource state and status information
Enumerations: Kubernetes API enums for consistent value usage
Patch Types: Strategic merge patch support for resource updates

// Type system imports
import * as inputs from "@pulumi/kubernetes/types/input";
import * as outputs from "@pulumi/kubernetes/types/output";
import * as enums from "@pulumi/kubernetes/types/enums";

// Example usage
const deployment: k8s.apps.v1.Deployment = new k8s.apps.v1.Deployment("app", {
    spec: {
        replicas: 3,
        selector: { matchLabels: { app: "nginx" } },
        template: {
            metadata: { labels: { app: "nginx" } },
            spec: {
                containers: [{
                    name: "nginx",
                    image: "nginx:1.21",
                    ports: [{ containerPort: 80 }],
                }],
                restartPolicy: enums.core.v1.RestartPolicy.Always,
            },
        },
    },
});

Getting Started

Install the package:
```
npm install @pulumi/kubernetes
```

Configure cluster access:

import * as k8s from "@pulumi/kubernetes";

const provider = new k8s.Provider("k8s", {
    kubeconfig: "~/.kube/config",
});

Deploy your first resource:

const namespace = new k8s.core.v1.Namespace("my-app", {
    metadata: { name: "my-application" },
});

Use deployment abstractions:

// YAML deployment
const app = new k8s.yaml.v2.ConfigFile("app", {
    files: ["./manifests/*.yaml"],
});

// Helm chart deployment
const chart = new k8s.helm.v4.Chart("nginx", {
    chart: "nginx",
    repositoryOpts: { repo: "https://charts.bitnami.com/bitnami" },
});

This comprehensive Kubernetes provider enables you to manage any Kubernetes resource with the full power of Pulumi's programming model, type safety, and infrastructure-as-code capabilities.

Install with Tessl CLI

npx tessl i tessl/npm-pulumi--kubernetes

Workspace: tessl
Visibility: Public
Created: 6 months ago
Last updated: about 1 month ago
Describes: pkg:npm/@pulumi/kubernetes@4.23.x
Publish Source: CLI
Badge