1. Docs
  2. Clouds
  3. Kubernetes
  4. Get started
  5. Review project

Pulumi & Kubernetes: Review project

    Let’s review some of the generated project files:

    • Pulumi.yaml defines both the project and the program that manages your stack resources.
    • src/main/java/myproject defines the project’s Java package root.
    • __main__.py is the Pulumi program that defines your stack resources.
    • index.js index.ts main.py main.go Program.cs Program.fs Program.vb App.java Pulumi.yaml is the Pulumi program that defines your stack resources.

    Let’s examine index.js index.ts __main__.py main.go Program.cs Program.fs Program.vb App.java Pulumi.yaml .

    "use strict";
    const k8s = require("@pulumi/kubernetes");
    
    const appLabels = { app: "nginx" };
    const deployment = new k8s.apps.v1.Deployment("nginx", {
        spec: {
            selector: { matchLabels: appLabels },
            replicas: 1,
            template: {
                metadata: { labels: appLabels },
                spec: { containers: [{ name: "nginx", image: "nginx" }] }
            }
        }
    });
    exports.name = deployment.metadata.name;
    
    import * as k8s from "@pulumi/kubernetes";
    
    const appLabels = { app: "nginx" };
    const deployment = new k8s.apps.v1.Deployment("nginx", {
        spec: {
            selector: { matchLabels: appLabels },
            replicas: 1,
            template: {
                metadata: { labels: appLabels },
                spec: { containers: [{ name: "nginx", image: "nginx" }] }
            }
        }
    });
    export const name = deployment.metadata.name;
    
    """A Kubernetes Python Pulumi program"""
    
    import pulumi
    from pulumi_kubernetes.apps.v1 import Deployment, DeploymentSpecArgs
    from pulumi_kubernetes.meta.v1 import LabelSelectorArgs, ObjectMetaArgs
    from pulumi_kubernetes.core.v1 import ContainerArgs, PodSpecArgs, PodTemplateSpecArgs
    
    app_labels = { "app": "nginx" }
    
    deployment = Deployment(
        "nginx",
        spec=DeploymentSpecArgs(
            selector=LabelSelectorArgs(match_labels=app_labels),
            replicas=1,
            template=PodTemplateSpecArgs(
                metadata=ObjectMetaArgs(labels=app_labels),
                spec=PodSpecArgs(containers=[ContainerArgs(name="nginx", image="nginx")])
            ),
        ))
    
    pulumi.export("name", deployment.metadata["name"])
    
    package main
    
    import (
    	appsv1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/apps/v1"
    	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
    	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    
    		appLabels := pulumi.StringMap{
    			"app": pulumi.String("nginx"),
    		}
    		deployment, err := appsv1.NewDeployment(ctx, "app-dep", &appsv1.DeploymentArgs{
    			Spec: appsv1.DeploymentSpecArgs{
    				Selector: &metav1.LabelSelectorArgs{
    					MatchLabels: appLabels,
    				},
    				Replicas: pulumi.Int(1),
    				Template: &corev1.PodTemplateSpecArgs{
    					Metadata: &metav1.ObjectMetaArgs{
    						Labels: appLabels,
    					},
    					Spec: &corev1.PodSpecArgs{
    						Containers: corev1.ContainerArray{
    							corev1.ContainerArgs{
    								Name:  pulumi.String("nginx"),
    								Image: pulumi.String("nginx"),
    							}},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    
    		ctx.Export("name", deployment.Metadata.Name())
    
    		return nil
    	})
    }
    
    using Pulumi;
    using Pulumi.Kubernetes.Types.Inputs.Core.V1;
    using Pulumi.Kubernetes.Types.Inputs.Apps.V1;
    using Pulumi.Kubernetes.Types.Inputs.Meta.V1;
    using System.Collections.Generic;
    
    return await Deployment.RunAsync(() =>
    {
        var appLabels = new InputMap<string>
        {
            { "app", "nginx" }
        };
    
        var deployment = new Pulumi.Kubernetes.Apps.V1.Deployment("nginx", new DeploymentArgs
        {
            Spec = new DeploymentSpecArgs
            {
                Selector = new LabelSelectorArgs
                {
                    MatchLabels = appLabels
                },
                Replicas = 1,
                Template = new PodTemplateSpecArgs
                {
                    Metadata = new ObjectMetaArgs
                    {
                        Labels = appLabels
                    },
                    Spec = new PodSpecArgs
                    {
                        Containers =
                        {
                            new ContainerArgs
                            {
                                Name = "nginx",
                                Image = "nginx",
                                Ports =
                                {
                                    new ContainerPortArgs
                                    {
                                        ContainerPortValue = 80
                                    }
                                }
                            }
                        }
                    }
                }
            }
        });
    
        // export the deployment name
        return new Dictionary<string, object?>
        {
            ["name"] =  deployment.Metadata.Apply(m => m.Name)
        };
    });
    
    package myproject;
    
    import com.pulumi.Pulumi;
    import com.pulumi.kubernetes.apps_v1.Deployment;
    import com.pulumi.kubernetes.apps_v1.DeploymentArgs;
    import com.pulumi.kubernetes.apps_v1.inputs.DeploymentSpecArgs;
    import com.pulumi.kubernetes.core_v1.inputs.ContainerArgs;
    import com.pulumi.kubernetes.core_v1.inputs.ContainerPortArgs;
    import com.pulumi.kubernetes.core_v1.inputs.PodSpecArgs;
    import com.pulumi.kubernetes.core_v1.inputs.PodTemplateSpecArgs;
    import com.pulumi.kubernetes.meta_v1.inputs.LabelSelectorArgs;
    import com.pulumi.kubernetes.meta_v1.inputs.ObjectMetaArgs;
    
    import java.util.Map;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(ctx -> {
                var labels = Map.of("app", "nginx");
    
                var deployment = new Deployment("nginx", DeploymentArgs.builder()
                        .spec(DeploymentSpecArgs.builder()
                                .selector(LabelSelectorArgs.builder()
                                        .matchLabels(labels)
                                        .build())
                                .replicas(1)
                                .template(PodTemplateSpecArgs.builder()
                                        .metadata(ObjectMetaArgs.builder()
                                                .labels(labels)
                                                .build())
                                        .spec(PodSpecArgs.builder()
                                                .containers(ContainerArgs.builder()
                                                        .name("nginx")
                                                        .image("nginx")
                                                        .ports(ContainerPortArgs.builder()
                                                                .containerPort(80)
                                                                .build())
                                                        .build())
                                                .build())
                                        .build())
    
                                .build())
                        .build());
    
                var name = deployment.metadata()
                    .applyValue(m -> m.orElseThrow().name().orElse(""));
    
                ctx.export("name", name);
            });
        }
    }
    
    name: quickstart
    runtime: yaml
    description: A minimal Kubernetes Pulumi YAML program
    
    variables:
      appLabels:
        app: nginx
    
    resources:
      deployment:
        name: nginx
        type: kubernetes:apps/v1:Deployment
        properties:
          spec:
            selector:
              matchLabels: ${appLabels}
            replicas: 1
            template:
              metadata:
                labels: ${appLabels}
              spec:
                containers:
                  - name: nginx
                    image: nginx
    
    outputs:
      name: ${deployment.metadata.name}
    

    This Pulumi program creates an NGINX deployment and exports the name of the deployment.

    Next, we’ll deploy the stack.

      Introducing Pulumi Copilot - Intelligent Cloud Management