CtrlK
BlogDocsLog inGet started
Tessl Logo

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

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

index.mddocs/

@pulumi/kubernetes

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

  1. Install the package:

    npm install @pulumi/kubernetes

  2. Configure cluster access:

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

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

  3. Deploy your first resource:

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

  4. 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.

docs

core-resources.md

helm-integration.md

index.md

kustomize-integration.md

networking-resources.md

provider-configuration.md

rbac-resources.md

storage-resources.md

workload-resources.md

yaml-deployment.md

tile.json