Pulumi enables you to describe the same infrastructure resources as real code, providing huge productivity gains, while decreasing the brittleness of YAML-based configuration files."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
Need help converting your CloudFormation templates into Pulumi code? Drop us a line.
-
-
-
-
-
'
+layout: cloudformation
+url: /cloudformation
---
diff --git a/content/migrate/terraform.md b/content/migrate/terraform.md
index 0d96cec4de54..b6f4801b4f13 100644
--- a/content/migrate/terraform.md
+++ b/content/migrate/terraform.md
@@ -1,30 +1,5 @@
---
title: "Migrate to Pulumi from Terraform"
-date: 2018-07-23T09:37:50-07:00
-layout: "terraform"
-page_class: "migrate"
-
-url: "/terraform"
-
-meta_title: "Migrate to Pulumi from Terraform"
-meta_desc: "How to migrate to Pulumi from Terraform for huge productivity gains, and a unified programming model for Devs and DevOps."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Infrastructure Automation"
-hero_title: "Migrating to Pulumi from Terraform"
-hero_description: "HashiCorp Terraform provides a custom DSL called Hashicorp Configuration Language (HCL) to describe and provision infrastructure resources on Terraform providers.
Pulumi enables you to describe the same infrastructure resources as real code, providing huge productivity gains, and has deep support for cloud native technologies such as Kubernetes and serverless programming."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
Need help converting your Terraform templates into Pulumi code? Drop us a line.
-
-
-
-
-
'
+layout: terraform
+url: /terraform
---
diff --git a/content/partner/aws.md b/content/partner/aws.md
index 931540acab17..9719b6d76bda 100644
--- a/content/partner/aws.md
+++ b/content/partner/aws.md
@@ -1,51 +1,5 @@
---
title: "Cloud Native Infrastructure as Code for AWS with Pulumi"
-date: 2018-07-23T09:37:50-07:00
-layout: "aws"
-page_class: "partner"
-
-url: "/aws"
-
-meta_title: "Cloud Native Infrastructure as Code for AWS with Pulumi"
-meta_desc: "Programming the AWS cloud with Pulumi for huge productivity gains, and a unified programming model for Devs and DevOps."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Native Infrastructure as Code"
-hero_title: "Program the cloud with Pulumi and AWS"
-hero_description: "Pulumi provides a cloud native programming model for AWS to create containers, serverless functions, and infrastructure, enabling the delivery of Cloud Native Infrastructure as Code, using real programming languages.
Find out how to program the cloud with Pulumi and AWS."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
-
-
-
-
-
const aws = require("@pulumi/aws");
-
- let size = "t2.micro";
- let ami = "ami-7172b611"
-
- let group = new aws.ec2.SecurityGroup("web-secgrp", {
- ingress: [
- { protocol: "tcp", fromPort: 22,
- toPort: 22, cidrBlocks: ["0.0.0.0/0"] },
- { protocol: "tcp", fromPort: 80,
- toPort: 80, cidrBlocks: ["0.0.0.0/0"] },
- ],
- });
-
- let server = new aws.ec2.Instance("web-server-www", {
- tags: { "Name": "web-server-www" },
- instanceType: size,
- securityGroups: [ group.name ],
- ami: ami,
- userData: userData
- });
-
-
-
'
+layout: aws
+url: /aws
---
diff --git a/content/pricing/_index.md b/content/pricing/_index.md
index bf6137a8e2bc..3b44ac4c0bd9 100644
--- a/content/pricing/_index.md
+++ b/content/pricing/_index.md
@@ -1,26 +1,8 @@
---
-title: "Pricing"
-date: 2018-06-04T15:07:49-07:00
-type: "page"
-layout: "pricing"
+title: Pricing
+type: page
+layout: pricing
menu:
- main:
+ header:
weight: 3
-
-hero_title: "Get support for Pulumi"
-hero_description: "Taking Pulumi into production? We can help.
The Pulumi framework is free and available to everyone. For teams, we provide an enterprise-grade platform, and support from our customer success teams. See below for more information.
Contact us for pricing details to suit your use of Pulumi."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
'
---
diff --git a/content/product/_index.md b/content/product/_index.md
index c4e96ea23043..e13e6fc9ac7f 100644
--- a/content/product/_index.md
+++ b/content/product/_index.md
@@ -1,50 +1,8 @@
---
-title: "Products"
-date: 2018-06-01T15:10:06-07:00
-layout: "product"
-identifier: "Products"
-type: "page"
+title: Products
+type: page
+layout: product
menu:
- main:
+ header:
weight: 1
- footer1:
- weight: 1
-
-hero_title: "The Pulumi Platform"
-hero_description: "Create, deploy, and manage cloud apps and infrastructure, for any cloud, in your favorite language. From infrastructure to containers to Kubernetes to serverless. Solutions for teams of all sizes, Dev and DevOps alike."
-hero_buttons: "Read the Docs"
-hero_right_content: '
'
---
diff --git a/content/product/github-actions.md b/content/product/github-actions.md
index 1938d58ee472..921f3b527515 100644
--- a/content/product/github-actions.md
+++ b/content/product/github-actions.md
@@ -1,19 +1,12 @@
---
-title: "GitHub Actions with Pulumi"
-date: 2018-06-01T15:10:06-07:00
-layout: "github-actions"
-menu:
- main:
- parent: "Products"
+title: GitHub Actions with Pulumi
+layout: github-actions
-meta_title: "GitHub Actions with Pulumi"
-meta_desc: "Pulumi and GitHub Actions combine to provide the easiest way to achieve continuous delivery of cloud applications and infrastructure."
-meta_image: "/images/pulumi.png"
+meta_title: GitHub Actions with Pulumi
+meta_desc: Pulumi and GitHub Actions combine to provide the easiest way to achieve continuous delivery of cloud applications and infrastructure.
+meta_image: /images/pulumi.png
-hero_title: "GitHub Actions with Pulumi"
-hero_description: "Pulumi and GitHub Actions combine to provide the easiest, most capable, and friction-free way to achieve continuous delivery of cloud applications and infrastructure."
-hero_buttons: "Read the Blog"
-hero_right_content: '
-
-
'
+menu:
+ main:
+ parent: Products
---
diff --git a/content/support.md b/content/support.md
index 5e490753f7ef..421346af42ce 100644
--- a/content/support.md
+++ b/content/support.md
@@ -1,11 +1,4 @@
---
-title: "Support"
-date: 2018-06-06T12:06:22-07:00
-layout: "support"
-menu:
- footer4:
- weight: 1
-
-hero_title: "Need support? We can help"
-hero_classes: "bg-purple white-text"
----
\ No newline at end of file
+title: Support
+layout: support
+---
diff --git a/content/topics/containers.md b/content/topics/containers.md
index 6f3e632163ce..63839c3dfdc4 100644
--- a/content/topics/containers.md
+++ b/content/topics/containers.md
@@ -1,43 +1,198 @@
---
-title: "Container Management with Pulumi"
-date: 2018-07-23T09:37:50-07:00
-layout: "containers"
-page_class: "topic"
-
-url: "/containers"
-
-meta_title: "Container Management with Pulumi"
-meta_desc: "Pulumi provides a cloud native programming model for container management. Any code, any cloud, any app."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Native Infrastructure as Code"
-hero_title: "Container Management with Pulumi"
-hero_description: "Pulumi provides a cloud native programming model for container management: deploy Docker to AWS Fargate, Microsoft ACI, and Kubernetes.
Any code, any cloud, any language."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
-
-
-
-
-
// Deploy Nginx to AWS Fargate
-
-import * as cloud from "@pulumi/cloud";
-
-
-let nginx = new cloud.Service("nginx", {
- image: "nginx",
- ports: [{ port: 80 }],
- replicas: 2,
-});
-
-
-export let url = nginx.defaultEndpoint;
-
-
-
'
+title: Container Management with Pulumi
+layout: containers
+url: /containers
+
+hero:
+ title: Container Management with Pulumi
+ body: >
+ Pulumi provides a cloud native programming model for container
+ management: deploy Docker to AWS Fargate, Microsoft ACI, and
+ Kubernetes.
+
+
+ Any code, any cloud, any language.
+ code: |
+ // Deploy Nginx to AWS Fargate
+ import * as cloud from "@pulumi/cloud";
+
+ let nginx = new cloud.Service("nginx", {
+ image: "nginx",
+ ports: [{ port: 80 }],
+ replicas: 2,
+ });
+
+ export let url = nginx.defaultEndpoint;
+
+sections:
+ - id: what-is-container-management
+ label: What is Container Management?
+ - id: deploying-containers
+ label: Deploying Containers
+ - id: code
+ label: Code
+ - id: get-started
+ label: Get Started
+ - id: contact
+ label: Contact Us
+
+examples:
+ - title: Deploy Nginx to AWS Fargate
+ body: >
+ In this example, Pulumi uses a multi-cloud cloud.Service object to pull the nginx
+ image from Docker Hub, and deploy it in a load-balanced way to AWS Fargate. Pulumi can
+ pull from any container registry.
+ code: |
+ // In Pulumi configuration
+ pulumi config set cloud-aws:useFargate true
+
+ // Deploy Nginx to AWS Fargate
+ import * as cloud from "@pulumi/cloud";
+
+ let nginx = new cloud.Service("nginx", {
+ image: "nginx",
+ ports: [{ port: 80 }],
+ replicas: 2,
+ });
+
+ export let url = nginx.defaultEndpoint;
+ cta:
+ url: /docs/quickstart/cloudfx/tutorial-service
+ label: GET STARTED
+
+ - title: Deploying with a custom build
+ body: >
+ This example uses a trivial Dockerfile that derives from the nginx base image and copies the
+ ./www directory into the nginx HTML target so that it will be served up.
+ code: |
+ // Using a custom build based on Nginx
+ import * as cloud from "@pulumi/cloud";
+
+ let nginx = new cloud.Service("nginx", {
+ build: ".",
+ ports: [{ port: 80 }],
+ replicas: 2,
+ });
+
+ export let url = nginx.defaultEndpoint;
+
+ // Dockerfile
+ FROM nginx
+ COPY ./www /usr/share/nginx/html
+ cta:
+ url: /docs/quickstart/cloudfx/tutorial-service
+ label: GET STARTED
+
+ - title: Connecting containers
+ body: >
+ This example shows how we can connect containers using Pulumi — in this case Redis for a data store,
+ and a Python flask app for a front end. Using Pulumi, it is easy to obtain a reference to the container
+ objects, and connect them using code.
+ code: |
+ import * as pulumi from "@pulumi/pulumi";
+ import * as cloud from "@pulumi/cloud";
+
+ // The data layer for the application
+ let redisCache = new cloud.Service("voting-app-cache", {
+ containers: {
+ redis: {
+ image: "redis:alpine",
+ memory: 512,
+ ports: [{ port: redisPort }],
+ command: ["redis-server", "--requirepass", redisPassword],
+ },
+ },
+ });
+
+ let redisEndpoint = redisCache.endpoints.apply(endpoints => endpoints.redis[redisPort]);
+
+ // A custom container for the frontend, which is a Python Flask app
+ let frontend = new cloud.Service("voting-app-frontend", {
+ containers: {
+ votingAppFrontend: {
+ build: "./frontend", // path to Dockerfile folder
+ memory: 512,
+ ports: [{ port: 80 }],
+ environment: {
+ // pass the Redis container info in environment variables
+ "REDIS": redisEndpoint.apply(e => e.hostname),
+ "REDIS_PORT": redisEndpoint.apply(e => e.port.toString()),
+ "REDIS_PWD": redisPassword
+ }
+ },
+ },
+ });
+
+ export let frontendURL = frontend.endpoints.apply(e => e["votingAppFrontend"][80].hostname);
+ cta:
+ url: /docs/quickstart/cloudfx/tutorial-service
+ label: GET STARTED
+
+ - title: Deploy containers to Microsoft ACI
+ body: >
+ The @pulumi/azure library provides fine-grained control of Azure resources. In this example,
+ we deploy a simple linux container to Microsoft ACI, in the West US zone.
+ code: |
+ import * as azure from "@pulumi/azure";
+
+ const resourceGroup = new azure.core.ResourceGroup("resourcegroup", {
+ location: "West US",
+ });
+
+ const containerGroup = new azure.containerservice.Group("containergroup", {
+ location: resourceGroup.location,
+ resourceGroupName: resourceGroup.name,
+ ipAddressType: "public",
+ osType: "linux",
+ containers: [
+ {
+ name: "hw",
+ image: "microsoft/aci-helloworld:latest",
+ cpu: 0.5,
+ memory: 1.5,
+ port: 80
+ },
+ ],
+ tags: {
+ "environment": "testing",
+ },
+ });
+ cta:
+ url: /docs/quickstart/cloudfx/tutorial-service
+ label: GET STARTED
+
+ - title: Invoke a long-running container as a task
+ body: >
+ This example shows a container used for executing a long-running task. Here, we use a container to
+ perform a thumbnail extraction on a piece of video uploaded to an S3 bucket.
+ code: |
+ let cloud = require("@pulumi/cloud-aws");
+
+ // A bucket to store videos and thumbnails.
+ let videos = new cloud.Bucket("bucket");
+
+ // A task which runs an FFMPEG transform to extract a thumbnail image.
+ let ffmpegThumbnailTask = new cloud.Task("ffmpegThumbTask", {
+ build: ".",
+ memoryReservation: 512,
+ });
+
+ // When a new video is uploaded, run the FFMPEG task on the video file.
+ videos.onPut("onNewVideo", args => {
+ let file = args.key;
+ ffmpegThumbnailTask.run({
+ environment: {
+ "S3_BUCKET": videos.bucket.name.get(),
+ "INPUT_VIDEO": file,
+ "TIME_OFFSET": file.substring(file.indexOf('_')+1, file.indexOf('.')).replace('-',':'),
+ "OUTPUT_FILE": file.substring(0, file.indexOf('_')) + '.jpg',
+ },
+ });
+ }, { keySuffix: ".mp4" });
+
+ exports.bucketName = videos.bucket.name;
+ cta:
+ url: /docs/quickstart/cloudfx/tutorial-service
+ label: GET STARTED
+
---
diff --git a/content/topics/infrastructure.md b/content/topics/infrastructure.md
deleted file mode 100644
index 1533ea022c92..000000000000
--- a/content/topics/infrastructure.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-title: "Infrastructure as Code with Pulumi"
-date: 2018-07-23T09:37:50-07:00
-layout: "infrastructure"
-page_class: "topic"
-draft: "true"
-
-url: "/infrastructure-as-code"
-
-meta_title: "Infrastructure as Code with Pulumi"
-meta_desc: "Pulumi provides a cloud native programming model for infrastructure as code. Any code, any cloud, any app."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Native Programming"
-hero_title: "Serverless Programming with Pulumi"
-hero_description: "Pulumi provides a cloud native programming model for infrastructure as code: from high-level multi-cloud, to fine-grained cloud-specific libraries.
Any code, any cloud, any language."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
-
-
-
-
-
// Create a serverless REST API
-
-import * as cloud from "@pulumi/cloud";
-
-let app = new cloud.API("my-app");
-app.static("/", "www");
-
-// Serve a simple REST API on `GET /hello`:
-
-app.get("/hello", (req, res) => res.json({ hello: "World!" }));
-
-export let url = app.publish().url;
-
-
-
'
----
diff --git a/content/topics/kubernetes.md b/content/topics/kubernetes.md
index 4f4c92497bf0..0a42282a5fc6 100644
--- a/content/topics/kubernetes.md
+++ b/content/topics/kubernetes.md
@@ -1,45 +1,246 @@
---
-title: "Kubernetes with Pulumi"
-date: 2018-07-23T09:37:50-07:00
-layout: "kubernetes"
-page_class: "topic"
-
-url: "/kubernetes"
-
-meta_title: "Kubernetes deployments with Pulumi"
-meta_desc: "Pulumi provides a cloud native programming model for Kubernetes deployments and orchestration. Any code, any cloud, any app."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Native Infrastructure as Code"
-hero_title: "Kubernetes with Pulumi"
-hero_description: "Pulumi provides a cloud native programming model for kubernetes deployments and orchestration: from on-premises to AWS EKS, Microsoft AKS, and Google GKE.
Any code, any cloud, any language."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
-
-
-
-
-
import * as k8sjs from "./k8sjs";
-
-let redis = new k8sjs.ServiceDeployment("redis", {
- image: "k8s.gcr.io/redis:e2e",
- ports: [ 6379 ]
-});
-
-let web = new k8sjs.ServiceDeployment("web", {
- replicas: 3,
- image: "gcr.io/google-samples/gb-frontend:v4",
- ports: [ 80 ],
- loadBalancer: true,
-});
-
-export let frontendIp = web.ipAddress;
-
-
-
'
+title: Kubernetes with Pulumi
+layout: kubernetes
+url: /kubernetes
+
+hero:
+ title: Kubernetes with Pulumi
+ body: >
+ Pulumi provides a cloud native programming model for kubernetes
+ deployments and orchestration: from on-premises to AWS EKS, Microsoft
+ AKS, and Google GKE.
+
+
+ Any code, any cloud, any language.
+ code: |
+ import * as k8sjs from "./k8sjs";
+
+ let redis = new k8sjs.ServiceDeployment("redis", {
+ image: "k8s.gcr.io/redis:e2e",
+ ports: [ 6379 ]
+ });
+
+ let web = new k8sjs.ServiceDeployment("web", {
+ replicas: 3,
+ image: "gcr.io/google-samples/gb-frontend:v4",
+ ports: [ 80 ],
+ loadBalancer: true,
+ });
+
+ export let frontendIp = web.ipAddress;
+
+sections:
+ - id: what-is-kubernetes
+ label: What is Kubernetes?
+ - id: kubernetes-everywhere
+ label: Kubernetes Everywhere
+ - id: code
+ label: Code
+ - id: get-started
+ label: Get Started
+ - id: contact
+ label: Contact Us
+
+examples:
+ - title: Define Kubernetes apps
+ body: >
+ In this example, we use TypeScript to define a trivial app - an nginx image - and
+ deploy 1 replica. Using a real language to define your app enables great IDE support —
+ compile time checking for instance.
+ code: |
+ import * as k8s from "@pulumi/kubernetes";
+
+ const appLabels = { app: "nginx" };
+
+ const deployment = new k8s.apps.v1.Deployment("nginx", {
+ spec: {
+ replicas: 1,
+ selector: { matchLabels: appLabels },
+ template: {
+ metadata: { labels: appLabels },
+ spec: { containers:
+ [{ name: "nginx", image: "nginx" }] }
+ }
+ }
+ });
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - title: Improve expressiveness, reduce boilerplate
+ body: >
+ Using real languages means being able to recognize patterns, and abstract them to reusable
+ componenents.
+
+ In this example we take a typical Deployment and Service pattern to create a ServiceDeployment
+ class, simplifying the implementation of the canonical Guestbook app.
+ code: |
+ import * as k8sjs from "./k8sjs";
+
+ let redisMaster = new k8sjs.ServiceDeployment("redis-master", {
+ image: "k8s.gcr.io/redis:e2e",
+ ports: [ 6379 ]
+ });
+
+ let redisSlave = new k8sjs.ServiceDeployment("redis-slave", {
+ image: "gcr.io/google_samples/gb-redisslave:v1",
+ ports: [ 6379 ]
+ });
+
+ let frontend = new k8sjs.ServiceDeployment("frontend", {
+ replicas: 3,
+ image: "gcr.io/google-samples/gb-frontend:v4",
+ ports: [ 80 ],
+ loadBalancer: true,
+ });
+
+ export let frontendIp = frontend.ipAddress;
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - title: Injecting sidecars using abstraction
+ body: >
+ Abstraction also allows us to do powerful work to simplify more complex configuration.
+ An example of this is the sidecar microservices pattern where a container runs
+ alongside other containers to add some functional value — logging, proxying etc.
+
+ In this case we define a simple EnvoyDeployment class that adds an Envoy sidecar to our Kubernetes app.
+ code: |
+ export class EnvoyDeployment extends k8s.apps.v1.Deployment {
+ constructor(name: string, args: k8stypes.apps.v1.Deployment, opts?: pulumi.CustomResourceOptions) {
+ const pod = args.spec.template.spec;
+
+ // Add an Envoy sidecar container.
+ pod.containers = pod.containers || [];
+ pod.containers.push({
+ name: "envoy",
+ // `lyft/envoy` does not tag releases. Use a SHA.
+ image: "lyft/envoy:4640fc028d65a6e2ee18858ebefcaeed24dffa81",
+ command: ["/usr/local/bin/envoy"],
+ args: [
+ "--concurrency 4",
+ "--config-path /etc/envoy/envoy.json",
+ "--mode serve"
+ ],
+ ports: [{ containerPort: 80, protocol: "TCP" }],
+ resources: {
+ limits: { cpu: "1000m", memory: "512Mi" },
+ requests: { cpu: "100m", memory: "64Mi" }
+ },
+ volumeMounts:
+ [{ name: "envoy-conf", mountPath: "/etc/envoy" }]
+ });
+
+
+ // Add a Volume for Envoy's config, as a ConfigMap.
+ pod.volumes = pod.volumes || [];
+ pod.volumes.push({
+ name: "envoy-conf", configMap: { name: "envoy" },
+ });
+
+ super(name, args, opts);
+ }
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - title: Use existing YAML and Helm Charts
+ body: >
+ Pulumi can also process YAML and Helm Charts, adding them to Pulumi programs which unlocks multi-cloud and advanced delivery scenarios.
+
+ These examples use YAML and Helm to deploy the Kubernetes Guestbook app and Wordpress.
+ code: |
+ // Use YAML
+ import * as k8s from "@pulumi/kubernetes";
+
+ const guestbook = new k8s.yaml.ConfigGroup(
+ "guestbook", { files: "guestbook/*.yaml" });
+
+ export const frontendIp =
+ guestbook.getResource("v1/Service", "frontend").
+ spec.apply(spec => spec.clusterIP);
+
+ //Use Helm
+ import * as k8s from "@pulumi/kubernetes";
+
+ const wordpress = new k8s.helm.v2.Chart("wordpress", {
+ repo: "stable",
+ version: "2.1.3",
+ chart: "wordpress"
+ });
+
+ export const frontendIp =
+ wordpress.getResource("v1/Service", "wpdev-wordpress").
+ status.apply(status => status.loadBalancer.ingress[0].ip);
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - title: Declare managed services alongside Kubernetes
+ body: >
+ Pulumi can be used to combine services. For instance, a Kubernetes cluster and an associated database (such as RDS).
+
+ In this example, we provision and use an AWS S3 bucket from a Kubernetes service.
+ code: |
+ import * as k8s from "@pulumi/kubernetes";
+ import * as aws from "@pulumi/aws";
+
+ const appName = "nginx";
+
+ // nginx config stored in an S3 bucket.
+ const config = new aws.s3.Bucket(`${appName}-config`);
+
+ // nginx container, replicated 1 time.
+ const appLabels = { app: appName };
+ const nginx = new k8s.apps.v1beta1.Deployment(appName, {
+ spec: {
+ selector: { matchLabels: appLabels },
+ replicas: 1,
+ template: {
+ metadata: { labels: appLabels },
+ spec: {
+ initContainers:
+ [nginxConfigPuller(config.bucketDomainName)],
+ containers:
+ [{ name: appName,
+ image: "nginx:1.15-alpine" }]
+ }
+ }
+ }
+ });
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - title: Provision Kubernetes clusters in any cloud
+ body: >
+ Kubernetes can be used in many environments — local dev, in the data center, self-hosted
+ in the cloud, and as a managed cloud service. Pulumi supports all of those options.
+
+ In this example, we show how to deploy a GKE cluster with configurable settings, which
+ can then be used to deploy apps to.
+ code: |
+ import * as gcp from "@pulumi/gcp";
+ import { nodeCount, nodeMachineType, password, username } from "./config";
+
+ export const k8sCluster = new gcp.container.Cluster("gke-cluster", {
+ initialNodeCount: nodeCount,
+ nodeVersion: "latest",
+ minMasterVersion: "latest",
+ masterAuth: { username, password },
+ nodeConfig: {
+ machineType: nodeMachineType,
+ oauthScopes: [
+ "https://www.googleapis.com/auth/compute",
+ "https://www.googleapis.com/auth/devstorage.read_only",
+ "https://www.googleapis.com/auth/logging.write",
+ "https://www.googleapis.com/auth/monitoring"
+ ],
+ },
+ });
+
+ cta:
+ url: /quickstart
+ label: GET STARTED
---
diff --git a/content/topics/serverless.md b/content/topics/serverless.md
index e567d463cc6b..982f97167c7a 100644
--- a/content/topics/serverless.md
+++ b/content/topics/serverless.md
@@ -1,42 +1,254 @@
---
-title: "Serverless Programming with Pulumi"
-date: 2018-07-23T09:37:50-07:00
-layout: "serverless"
-page_class: "topic"
-
-url: "/serverless"
-
-meta_title: "Serverless Programming with Pulumi"
-meta_desc: "Pulumi provides a cloud native programming model for serverless applications. Any code, any cloud, any app."
-meta_image: "/images/pulumi.png"
-
-topic: "Cloud Native Infrastructure as Code"
-hero_title: "Serverless Programming with Pulumi"
-hero_description: "Pulumi provides a cloud native programming model for serverless applications: from high-level multi-cloud, to fine-grained cloud-specific libraries.
Any code, any cloud, any language."
-hero_classes: "bg-purple white-text"
-hero_right_content: '
-
-
-
-
-
-
-
-
-
-
// Create a serverless REST API
-
-import * as cloud from "@pulumi/cloud";
-
-let app = new cloud.API("my-app");
-app.static("/", "www");
-
-// Serve a simple REST API on `GET /hello`:
-
-app.get("/hello", (req, res) => res.json({ hello: "World!" }));
-
-export let url = app.publish().url;
-
-
-
'
+title: Serverless Programming with Pulumi
+layout: serverless
+url: /serverless
+
+hero:
+ title: Serverless Programming with Pulumi
+ body:
+ Pulumi provides a cloud native programming model for serverless
+ applications — from high-level multi-cloud, to fine-grained
+ cloud-specific libraries.
+
+
+ Any code, any cloud, any language.
+ code: |
+ // Create a serverless REST API
+ import * as cloud from "@pulumi/cloud";
+
+ let app = new cloud.API("my-app");
+ app.static("/", "www");
+
+ // Serve a simple REST API on `GET /hello`:
+ app.get("/hello", (req, res) =>
+ res.json({ hello: "World!" }));
+
+ export let url = app.publish().url;
+
+sections:
+ - id: what-is-serverless
+ label: What is Serverless?
+ - id: serverless-building-blocks
+ label: Serverless Building Blocks
+ - id: code
+ label: Code
+ - id: get-started
+ label: Get Started
+ - id: contact
+ label: Contact Us
+
+examples:
+ - id: code-api
+ title: Creating a Serverless REST API
+ body: >
+ This example shows how to create a simple REST API that counts the number of times a
+ route has been hit. To implement this API, we need a DynamoDB table, an API endpoint,
+ and a Lambda function.
+ code: |
+ const cloud = require("@pulumi/cloud-aws");
+
+ // Create a mapping from 'route' to a count
+ let counterTable = new cloud.Table("counterTable", "route");
+
+ // Create an API endpoint
+ let endpoint = new cloud.API("hello-world");
+
+ endpoint.get("/{route+}", (req, res) => {
+ let route = req.params["route"];
+ console.log(`Getting count for '${route}'`);
+
+ // get previous value and increment
+ // reference outer `counterTable` object
+ counterTable.get({ route }).then(value => {
+ let count = (value && value.count) || 0;
+ counterTable.insert({ route, count: ++count }).then(()
+ => {
+ res.status(200).json({ route, count });
+ console.log(`Got count ${count} for '${route}'`);
+ });
+ });
+ });
+
+ exports.endpoint = endpoint.publish().url;
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-bucket
+ title: Using storage buckets easily
+ body: >
+ Pulumi makes it easy to setup storage in the cloud. Events raised by the storage object can be handled by Lambda functions as actual lambdas in code.
+
+
+ This example sets up a storage bucket (using S3 on AWS) and a simple Lambda function to respond to new items being added to the bucket.
+ code: |
+ const cloud = require("@pulumi/cloud-aws");
+
+ // A storage bucket
+ const bucket = new cloud.Bucket("bucket");
+ const bucketName = bucket.bucket.id;
+
+
+ // Trigger a Lamda function when something is added
+ bucket.onPut("onNewVideo", bucketArgs => {
+ console.log(`*** New Item in Bucket`);}
+
+ // Export the bucket name.
+ exports.bucketName = bucketName;
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-table
+ title: Stash info into a document database
+ body: >
+ This example uses a serverless timer that fetches the Hacker News homepage every hour and
+ stashes it into a document database, making use of Pulumi's ability to reference the
+ cloud.table object.
+ code: |
+ import * as cloud from "@pulumi/cloud";
+
+ let snapshots = new cloud.Table("snapshots");
+
+ cloud.timer.daily("daily-yc-snapshot",
+ { hourUTC: 0, minuteUTC: 0 }, () => {
+ let req = require("https")
+ .get("https://news.ycombinator.com", (res) => {
+ let content = "";
+ res.setEncoding("utf8");
+ res.on("data", (chunk) => { content += chunk });
+ res.on("end", () => {
+ snapshots.insert({ date: Date.now(),
+ content: content });
+ });
+ });
+ req.end();
+ });
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-timer
+ title: Super-simple serverless cron jobs
+ body: >
+ Pulumi’s Cloud Framework has a timer module that lets you schedule cron jobs that run
+ serverless functions. This is the easiest way to get up and running with serverless
+ functions, because you don’t even need any other resources to trigger events from.
+
+
+ There are several ways to schedule a timer, depending on your stylistic preferences. These
+ examples simply print the current time to the console on a given interval.
+ code: |
+ import * as cloud from "@pulumi/cloud";
+
+ // Run a timer every minute:
+ cloud.timer.interval("interval-timer", { minutes: 0 }, () => {
+ console.log(`interval-timer: ${Date.now()}`);
+ });
+
+ // Run a timer every minute (cron-style expression):
+ cloud.timer.cron("cron-timer", "0 * * * * *", () => {
+ console.log(`cron-timer: ${Date.now()}`);
+ });
+
+ // Run a timer every day at 7:30 UTC:
+ cloud.timer.daily("daily-timer", { hourUTC: 7, minuteUTC: 30 }, () => {
+ console.log(`daily-timer: ${Date.now()}`);
+ });
+
+ // Run a timer at the 45th minute UTC of every hour:
+ cloud.timer.hourly("hourly-timer", { minuteUTC: 45 }, () => {
+ console.log(`hourly-timer: ${Date.now()}`);
+ });
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-queue
+ title: Post AWS SQS Messages to Slack
+ body: >
+ This example wires up a serverless AWS Lambda to an AWS SQS queue and demonstrates posting
+ a message to Slack. This program provisions resources using Pulumi's deployment system,
+ but lets you write serverless code as ordinary JavaScript functions.
+ code: |
+ let aws = require("@pulumi/aws");
+ let serverless = require("@pulumi/aws-serverless");
+ let config = require("./config");
+
+ let queue = new aws.sqs.Queue("mySlackQueue", { visibilityTimeoutSeconds: 180 });
+
+ serverless.queue.subscribe("mySlackPoster",
+ queue, async (e) => {
+ let slack = require("@slack/client");
+ let client = new slack.WebClient(config.slackToken);
+ for (let rec of e.Records) {
+ await client.chat.postMessage({
+ channel: config.slackChannel,
+ text: `*Msg ${rec.messageId}*:\n${rec.body}\n`+
+ `(with :love_letter: from Pulumi)`,
+ as_user: true,
+ });
+ console.log(`Posted SQS message ${rec.messageId} to ${config.slackChannel}`);
+ }
+ }, { batchSize: 1 });
+
+ module.exports = {
+ queueURL: queue.id,
+ };
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-topic
+ title: Subscribe to an SNS endpoint
+ body: >
+ This example users a timer to trigger a notification which then recursively
+ triggers itself to countdown from 25..0 every five minutes.
+ code: |
+ import * as pulumi from "@pulumi/cloud";
+
+ let countDown = new pulumi.Topic("examples-countDown");
+
+ countDown.subscribe("watcher", async (num) => {
+ console.log(num);
+ if (num > 0) {
+ await countDown.publish(num - 1);
+ }
+ });
+
+ pulumi.timer.interval("examples-heartbeat", {minutes: 5}, async () => {
+ await countDown.publish(25);
+ });
+ cta:
+ url: /quickstart
+ label: GET STARTED
+
+ - id: code-state-machine
+ title: Create state machines of functions
+ body: >
+ This example shows a very simple state machine using AWS Step Functions. When
+ executed the state machine steps will execute the 'Hello' and then 'World', steps
+ in order before exiting.
+ code: |
+ import * as aws from "@pulumi/aws";
+ import * as pulumi from "@pulumi/pulumi";
+
+ const helloFunction = new aws.serverless.Function(
+ "helloFunction",
+ { role: lambdaRole },
+ (event, context, callback) => {
+ callback(null, "Hello");
+ }
+ );
+
+ const worldFunction = new aws.serverless.Function(
+ "worldFunction",
+ {role: lambdaRole},
+ (event, context, callback) => {
+ callback(null, `${event} World!`);
+ }
+ );
+ cta:
+ url: /quickstart
+ label: GET STARTED
---
diff --git a/content/webinar/aws-fargate-and-pulumi.md b/content/webinar/aws-fargate-and-pulumi.md
index 2ee22ec6f5a2..0fdaef46dd23 100644
--- a/content/webinar/aws-fargate-and-pulumi.md
+++ b/content/webinar/aws-fargate-and-pulumi.md
@@ -1,9 +1,52 @@
---
-title: "AWS Fargate and Pulumi"
-date: 2019-01-03T13:02:18-08:00
-layout: "aws-fargate-and-pulumi"
+title: "Pulumi in IoT Webinar: AWS, Mapbox and Pulumi"
+layout: webinar
-meta_title: "Delivering Cloud Native Infrastructure as Code with Pulumi and AWS"
-meta_desc: "Join the upcoming webinar to learn how to unify your development and DevOps teams by using the power of general purpose programming languages to create modern, cloud native applications"
-meta_image: "/images/pulumi.png"
+hero:
+ title: Delivering Cloud Native Infrastructure as Code with Pulumi and AWS
+ image: /icons/containers.svg
+
+logos:
+ - name: aws
+ image: /logos/tech/logo-aws.png
+ - name: Pulumi
+ image: /logos/logo.svg
+
+main:
+ heading: Let's program the cloud
+
+ description: >
+ Pulumi's Cloud Native Development Platform streamlines DevOps processes and the delivery of cloud native software. Pulumi unlocks the power of general-purpose programming languages to equip your organization with the tools necessary to quickly build and deploy containers on AWS.
+
+
+ Pulumi provides huge productivity gains of your favorite language: from testability, to code completion, error checking, packaging, versioning, and IDE support.
+
+ cta:
+ label: Watch the Recording
+ url: https://www.youtube.com/watch?v=M1Es9e9ICJA&t=1251s
+
+ learn:
+ - How using general purpose programming languages provides familiar and powerful programming concepts
+ - How Pulumi can help build a library of code packages to enhance efficiency
+ - Best practices for becoming a deployment-focused organization
+
+webinar:
+ title: Creating modern, cloud native applications by unifying your DevOps teams
+ datetime: 2019-02-05 10:00:00 -07:00
+ description: >
+ Join the webinar to learn how to unify your development and DevOps teams by using the power of general purpose programming languages to create modern, cloud native applications.
+
+ presenters:
+ - name: Trevor Hansen
+ role: Startup Partner Solutions Architect, AWS
+ - name: Luke Hoban
+ role: CTO, Pulumi
+ - name: Chris Toomey
+ role: CTO & Principal Architect, Learning Machine
+
+ audience:
+ - Developers
+ - System Architects
+ - IT Managers
+ - DevOps Managers
---
diff --git a/content/webinar/aws-mapbox.md b/content/webinar/aws-mapbox.md
index 1774684acec4..e47bab6a77ca 100644
--- a/content/webinar/aws-mapbox.md
+++ b/content/webinar/aws-mapbox.md
@@ -1,8 +1,60 @@
---
title: "Pulumi in IoT Webinar: AWS, Mapbox and Pulumi"
-layout: "aws-mapbox"
+layout: webinar
-meta_title: "Pulumi in IoT: Serverless Asset Tracking Solution"
-meta_desc: "Join us in the webinar to see how Pulumi supercharges Mapbox’s IoT asset tracking architecture on AWS, from API Gateway, Amazon Kinesis, to DynamoDB and S3."
-meta_image: "/images/pulumi.png"
+hero:
+ title: "Pulumi in IoT: Serverless Asset Tracking Solution"
+ image: /icons/containers.svg
+
+logos:
+ - name: aws
+ image: /logos/tech/logo-aws.png
+ - name: Pulumi
+ image: /logos/logo.svg
+ - name: mapbox
+ image: /logos/customers/mapbox_logo.png
+
+main:
+ heading: "IoT-as-Code, the Serverless Way"
+
+ description: >
+ Serverless compute services offer an amazing power to application developers to leverage: highly available, automatically scaled, low-ceremony, pay-per-value functions created in several lines of code. With Pulumi’s cloud native SDKs, serverless gets more fun. Using general purpose languages, we can create resources, and then wire up event handlers, like in normal event-driven programming!
+
+
+ Join us in the webinar to see how Pulumi supercharges Mapbox’s IoT asset tracking architecture on AWS, from API Gateway, Amazon Kinesis, to DynamoDB and S3.
+
+ cta:
+ label: Watch the Recording
+ url: https://event.on24.com/wcc/r/2000709/49822D39F0E9038AA2A3A84E04BF575D?partnerref=pulumi
+
+ learn:
+ - The challenge of tracking assets and why real-time location data matters
+ - Why current technologies fall short—especially at scale
+ - How to compile an asset tracking solution using modern, serverless technology with Pulumi, AWS, and Mapbox
+ - "Pulumi Live demo: Asset tracking at work"
+ - "Programing your cloud applications with TypeScript, JavaScript, or Python: Pulumi SDKs and SaaS console"
+ - Why serverless tech matters and what it enables
+
+webinar:
+ title: "Modernizing Logistics: How to program an asset tracking architecture using serverless technologies"
+ datetime: 2019-06-13 11:00:00 -07:00
+ description: >
+ Join Pulumi, AWS, and Mapbox as we discuss how you can transition from antiquated
+ technology to modern, serverless infrastructure to build an asset tracking solution
+ that scales globally, facilitates end-to-end data ownership, and adapts to the unique
+ needs of your business.
+
+ presenters:
+ - name: Trevor Hansen
+ role: Startup Partner Solutions Architect, AWS
+ - name: Cameron Stokes
+ role: Customer Engineer, Pulumi
+ - name: Chris Toomey
+ role: Solutions Architect Lead, Mapbox
+
+ audience:
+ - Developers
+ - System Architects
+ - IT Managers
+ - DevOps Managers
---
diff --git a/content/why-pulumi/_index.md b/content/why-pulumi/_index.md
index c59c9d8a84b2..10982f8ec44d 100644
--- a/content/why-pulumi/_index.md
+++ b/content/why-pulumi/_index.md
@@ -1,20 +1,8 @@
---
-title: "Why Pulumi"
-date: 2018-06-01T15:10:06-07:00
-type: "page"
-# menu:
-# main:
-# identifier: "why-pulumi"
-# weight: 2
-
-meta_title: "Cloud Apps and Infrastructure"
-meta_desc: "The Pulumi Platform includes an open source SDK and SaaS to create, deploy, and manage cloud apps and infrastructure, across any clouds."
-meta_image: "/images/pulumi.png"
-
-hero_title: "Cloud Apps and Infrastructure"
-hero_description: "The Pulumi Platform includes an open source SDK and freemium SaaS to help developers, DevOps, and IT teams alike create, deploy, and manage cloud apps and infrastructure, across any clouds, with one consistent workflow."
-hero_img: "/images/logo-neon.png"
-hero_img_width: "300px"
-hero_buttons: "Download the White Paper"
-hero_display_breadcrumb: true
+title: Why Pulumi
+type: page
+layout: why-pulumi
+menu:
+ header:
+ weight: 2
---
diff --git a/content/why-pulumi/delivering-cloud-native-infrastructure-as-code.md b/content/why-pulumi/delivering-cloud-native-infrastructure-as-code.md
index 93d6729abbdf..a2cb58d677ce 100644
--- a/content/why-pulumi/delivering-cloud-native-infrastructure-as-code.md
+++ b/content/why-pulumi/delivering-cloud-native-infrastructure-as-code.md
@@ -1,19 +1,32 @@
---
-title: "Delivering Cloud Native Infrastructure as Code"
-date: 2018-11-23T14:14:08-08:00
-
-meta_title: "Delivering Cloud Native Infrastructure as Code"
-meta_desc: "In this paper, we make the case for a consistent cloud programming model using general purpose programming languages for infrastructure, managed services, containers, Kubernetes, and serverless."
-meta_image: "/images/pulumi.png"
-
-type: "whitepaper"
-hero_title: "Delivering Cloud Native Infrastructure as Code"
-hero_classes: "bg-blue-dark white-text smaller-smaller-padding no-padding-bottom hero-whitepaper"
-hero_description: "Enabling the future of cloud engineering with Pulumi
Download the whitepaper"
-hero_img: "/images/whitepaper/cloud-native-infrastructure/deliveringCloudNative_pdf_large.png"
-exec_sum_title: "Executive Summary"
-exec_sum: "To a first approximation, all developers are cloud developers, all applications are cloud native, and all operations are cloud-first. Yet, there is a lack of a consistent approach to delivering cloud native applications and infrastructure. The tools and processes differ by technology generation, and even by cloud vendor, and so deny the full potential of cloud native application delivery."
+title: Delivering Cloud Native Infrastructure as Code
+description: Enabling the future of cloud engineering with Pulumi
+type: page
+layout: whitepaper
+
+hero_image: /images/whitepaper/cloud-native-infrastructure/deliveringCloudNative_pdf_large.png
+
+summary: To a first approximation, all developers are cloud developers, all applications are cloud native, and all operations are cloud-first. Yet, there is a lack of a consistent approach to delivering cloud native applications and infrastructure. The tools and processes differ by technology generation, and even by cloud vendor, and so deny the full potential of cloud native application delivery.
+
+download_url: "https://cdn2.hubspot.net/hubfs/4429525/Content/Pulumi-Delivering-CNI-as-Code.pdf"
+
+sections:
+ - label: Exec Summary
+ anchor: executive-summary
+ - label: Challenges
+ anchor: the-challenges-of-cloud-development-and-devops
+ - label: Solutions
+ anchor: pulumi-provides-a-cloud-native-programming-model
+ - label: Use Cases
+ anchor: use-cases
+ - label: Conclusion
+ anchor: conclusion
+
+meta_title: Delivering Cloud Native Infrastructure as Code
+meta_image: /images/pulumi.png
+meta_desc: In this paper, we make the case for a consistent cloud programming model using general purpose programming languages for infrastructure, managed services, containers, Kubernetes, and serverless.
---
+
In this paper, we make the case for a consistent programming model for the cloud and examine:
* How the cloud has already evolved three times as it increasingly moves toward stateless compute to deliver on the opportunities afforded by unprecedented economies of scope and scale.
@@ -39,15 +52,13 @@ In doing so, cloud computing has been continuously driving towards event-driven
As usual, the future is unevenly distributed. A quick look at Google Trends over five years provides a reasonably clear picture of how embedded these evolutions are in the market at large. In this view, we use the presumed category incumbents to represent the market.
-
-
-
INTEREST OVER TIME, 5 Years to Current Date
+#### Interest Over Time, 5 Years to Current Date
-
+
We can redraw this picture as an adoption curve across these evolutions approximately as follows:
-
+
Each of these evolutions has opportunity, but also embedded cost: cost to switch, cost of skills, and cost of workflows and tools. Each also carries risk through isolated stovepipes: limited numbers of experts to attend to a given paradigm.
@@ -87,7 +98,7 @@ Using real languages changes everything. [The Pulumi Cloud Development Platform]
At the center of Pulumi is an open source cloud object model, coupled with an evaluation runtime that understands how to take programs written in any language, understand the cloud resources necessary to execute them, and then plan and manage those resources in a robust way. This cloud runtime and object model is inherently language- and cloud-neutral, enabling Pulumi to support many languages and clouds rapidly.
-
+
Pulumi aims to provide a solution to the challenges of cloud application development and delivery by providing a consistent programming model for cloud native development:
@@ -117,32 +128,33 @@ As the Pulumi runtime can support many languages, development and devops teams g
Real languages also means gaining access to powerful - but obvious - benefits: capture references to variables such as constants, configuration settings or encrypted secrets, or even references to other resources so that all resources can be connected in an expressive and logical manner to achieve the desired output.
-
-import * as aws from "@pulumi/aws";
+```javascript
+import * as aws from "@pulumi/aws";
import * as serverless from "@pulumi/aws-serverless";
+
let topic = new aws.sns.Topic("topic");
+
serverless.cloudwatch.onEvent("hourly", "rate(60 minutes)", event => {
- const sns = new (await import "aws-sdk").SNS();
- return sns.publish({
- Message: JSON.stringify({ event: event }),
- TopicArn: topic.id.get(),
- }).promise();
+ const sns = new (await import "aws-sdk").SNS();
+ return sns.publish({
+ Message: JSON.stringify({ event: event }),
+ TopicArn: topic.id.get(),
+ }).promise();
});
-
-
+```
**Abstraction and reuse.** Real development languages o er abstraction, and as a result, reuse of code. Pulumi supports the appropriate package managers for the chosen development language (e.g. NPM for JS/TS, PyPi for Python). This allows the elimination of significant LoC from a typical DSL- based configuration, and removes the practice of copy-and-paste development with its inherent drift and error replication risks.
This example code shows the refactoring of a typical AWS Best Practice for setting up a VPC, and how it can be reused and instantiated as needed in new Pulumi programs.
-
-import * as awsinfra from "@pulumi/aws-infra";
+```javascript
+import * as awsinfra from "@pulumi/aws-infra";
+
let network = new awsinfra.Network(`${prefix}-net`, {
- numberOfAvailabilityZones: 3, // Create subnets in many AZs
- usePrivateSubnets: true, // Run inside private per-AZ subnets
+ numberOfAvailabilityZones: 3, // Create subnets in many AZs.
+ usePrivateSubnets: true, // Run inside private per-AZ subnets.
});
-
-
+```
**Tooling and workflows.** By using real languages, development and devops teams instantly gain access to IDEs, refactoring, testing, static analysis and linters, and so much more. This both improves the productivity and quality of team efforts, and throws into harsh relief the lack of tooling for DSL- based approaches, which is often hard to debug and remediate.
@@ -156,7 +168,7 @@ Because infrastructure is now linked to application code, and because of the eph
Previously there was very limited tooling at the very point of collaboration needed by development and devops teams. Pulumi connects those teams and improves the required workflows.
-
+
**Delivering Cloud 'Stacks'.** A core concept in Pulumi is the idea of a "stack." A stack is an isolated instance of a cloud program whose resources and configuration are distinct from all other stacks. A team might have a stack each for production, staging, and testing, or perhaps for each single- tenanted environment. Pulumi's CLI makes it trivial to spin up and tear down lots of stacks. This opens up workflows that might not have previously even attempted, such as each developer having her own stack, spinning up (and tearing down) a fresh stack to test out each Pull Request, or even splitting tiers of your service into many stacks that are linked together - all of which is applicable and useful in cloud application deliver scenarios.
@@ -166,92 +178,99 @@ Previously there was very limited tooling at the very point of collaboration nee
## Use Cases
-
Pulumi provides a consistent programming model across the cloud, from VMs through containers and Kubernetes, to serverless and managed services.
-
-
-
Infrastructure. Managed cloud services and infrastructure, continuously deployed and con gured in a robust and compliant manner.
-
-
-// Create a simple web server
+### Infrastructure
+Managed cloud services and infrastructure, continuously deployed and con gured in a robust and compliant manner.
+
+```javascript
+// Create a simple web server.
const aws = require("@pulumi/aws");
+
let size = "t2.micro";
let ami = "ami-7172b611"
-let server = new aws.ec2.Instance("web-
-server-www", {
- tags: { "Name":"web-server-www" },
+
+let server = new aws.ec2.Instance("web-server-www", {
+ tags: { "Name": "web-server-www" },
instanceType: size,
securityGroups: [ group.name ],
ami: ami,
userData: userData
});
+
exports.publicIp = server.publicIp;
exports.publicHostName = server.publicDns;
-
-
-
-
-
-
-
Kubernetes. Target on-premises or cloud-based Kubernetes services to provision clusters, and create, deploy, and manage apps.
-
-
-// Deploy 3 replicas of an nginx pod
+```
+
+### Kubernetes
+Target on-premises or cloud-based Kubernetes services to provision clusters, and create, deploy, and manage apps.
+
+```javascript
+// Deploy 3 replicas of an Nginx pod.
import * as k8s from "@pulumi/kubernetes";
+
function deploy(name, replicas, pod) {
return new k8s.apps.v1beta1.Deployment(name, {
spec: {
- selector: { matchLabels: pod.metadata
-labels },
- replicas: replicas,
- template: pod
- }
-}); }
+ selector: {
+ matchLabels: pod.metadata.labels
+ },
+ replicas: replicas,
+ template: pod
+ }
+ });
+}
+
const nginxServer = deploy("nginx", 3, {
- metadata: { labels: { app: "nginx" } },
+ metadata: {
+ labels: {
+ app: "nginx"
+ }
+ },
spec: {
- containers: [{ name: "nginx",
- image: "nginx:1.15-alpine" }]
-} });
-
-
-
-
-
-
-
Serverless. Deploy and scale websites easily, handle event-streaming, and processing with multi-cloud microservices.
-
-
-// Create a serverless REST API
+ containers: [
+ {
+ name: "nginx",
+ image: "nginx:1.15-alpine"
+ }
+ ]
+ }
+});
+```
+
+### Serverless
+Deploy and scale websites easily, handle event-streaming, and processing with multi-cloud microservices.
+
+```javascript
+// Create a serverless REST API.
import * as cloud from "@pulumi/cloud";
+
let app = new cloud.API("my-app");
app.static("/", "www");
-// Serve a simple REST API on `GET /hello`:
-app.get("/hello", (req, res) =>
- res.json({ hello: "World!" }));
+// Serve a simple REST API on `GET /hello`.
+app.get("/hello", (req, res) => {
+ res.json({ hello: "World!" }));
+}
+
export let url = app.publish().url;
-
-
-
-
-
-
-
Containers. Deploy container-based apps into any cloud native infrastructure, from VMs to Kubernetes, to custom orchestrators.
-
-
-// Deploy a custom container image based on nginx
+```
+
+### Containers
+Deploy container-based apps into any cloud native infrastructure, from VMs to Kubernetes, to custom orchestrators.
+
+```javascript
+// Deploy a custom container image based on nginx.
import * as cloud from "@pulumi/cloud";
+
let nginx = new cloud.Service("nginx", {
build: ".",
ports: [{ port: 80 }],
replicas: 2,
});
+
export let url = nginx.defaultEndpoint;
-
-
-
+```
### Delivering Cloud Native Infrastructure for Learning Machine
@@ -264,12 +283,11 @@ Learning Machine suffered from a loss of productivity and an inability to meet b
By using Pulumi, Learning Machine were able to reduce 25,000 LoC of ad-hoc scripts to 500 LoC of JavaScript that could be understood across all teams, enabling the development team to take accountability for service delivery to meet business needs. Additionally, moving to Pulumi removes lock-in to a specific cloud, and has enabled Learning Machine to begin work on their on-premises private cloud service.
-
+
+
+> Pulumi has given our team the tools and framework to achieve a unified development and DevOps model, boosting productivity and taking our business to any cloud environment that our customers need. We retired 25,000 lines of complex code that few team members understood and replaced it with 100s of lines in a real programming language.
-
-
"Pulumi has given our team the tools and framework to achieve a unified development and DevOps model, boosting productivity and taking our business to any cloud environment that our customers need. We retired 25,000 lines of complex code that few team members understood and replaced it with 100s of lines in a real programming language."
-
-
+— Kim Hamilton, CTO, Learning Machine
## Conclusion
@@ -284,5 +302,3 @@ Pulumi provides a platform to deliver cloud native infrastructure as code for an
Cloud Native development represents a step change in opportunity, and capabilities, for development and devops teams. Pulumi brings together those teams to ensure their success through huge productivity and quality gains with a Cloud Native Development Platform designed for every cloud evolution.
> The rapid pace of evolution of the cloud, combined with the shift to ephemeral infrastructure, and the connection of application code and infrastructure code, demands a different view of cloud development and devops.
-
-
diff --git a/content/why-pulumi/point-of-view.md b/content/why-pulumi/point-of-view.md
index 2ade075b9a5f..9d5be719ef26 100644
--- a/content/why-pulumi/point-of-view.md
+++ b/content/why-pulumi/point-of-view.md
@@ -1,17 +1,6 @@
---
-title: "Point of View"
-date: 2018-06-05T15:48:28-07:00
-# menu:
-# main:
-# parent: "why-pulumi"
-
-meta_title: "Toward a Cloud Native Programming Model"
-meta_desc: "Pulumi provides a Cloud Native Programming Model for Containers, Lambdas, and Infrastructure, to get code to the cloud faster than ever before."
-meta_image: "/images/pulumi.png"
-
-hero_title: "Toward a Cloud Native Programming Model"
-hero_description: "Cloud innovation has delivered limitless capabilities that promise to transform all aspects of software development."
-hero_display_breadcrumb: true
+title: Point of View
+description: Cloud innovation has delivered limitless capabilities that promise to transform all aspects of software development.
---
This radical democratization is thanks to containers, serverless (lambda) computing, and opinionated data and infrastructure services, leveling the playing field, lowering barriers to entry, and delivering the closest thing to an "operating system for the cloud" that we've ever seen.
@@ -20,46 +9,36 @@ This radical democratization is thanks to containers, serverless (lambda) comput
However, cloud developers lack a consistent programming model to provide the productivity gains for application development harnessing these capabilities. Pulumi aims to provide that programming model.
-
-
Transforming to Cloud Native
-
+
The set of capabilities, and cloud native architecture, derived from containers, lambda, and data (CoLaDa) services are promising the delivery of new applications at high velocity, that are delivered on-demand at any scale and freed from the constraints of traditional data center infrastructure.
The leading Developers and DevOps teams will want tools, frameworks, and automation that is specific to this programming model, and works the way they want, to maximize their velocity for software delivery. "Infrastructure" requirements -- the set of services that apps are built upon -- are increasingly being decided by Developers and DevOps teams, who are making extensive use of automation to manage the available portfolio for their enterprises.
The programming models, however -- the lingua franca developers use to express themselves -- have not kept pace. This is no surprise: we are still transitioning from past generations of cloud compute, which mainly entailed gluing together virtual machines with configuration files managed by operators, and not developers. We have come a long way, and yet we are still very early on the journey towards our future cloud-oriented distributed programming nirvana.
-
-
Beyond Lift and Shift
+
To put this transition into perspective, until just recently "getting code to the cloud" meant "lift and shift": taking aging n-tier web apps, dusting them off with minimal changes, and rehosting them in the public cloud. This may yield significant cost savings, allowing organizations to reduce or retire their own data center expenditures, while also improving agility. For many organizations, much of the promise behind containers is to increase the scope of this approach.
Because of the nature of lift and shift, however, the tools developers use to create and manage cloud software have progressed slowly. One of the benefits of containers has been giving developers simpler tools and workflows to package up their code to deploy into the cloud. But operating such programs at scale and in production -- and architecting these programs in a truly cloud native way -- is still the domain of cutting edge experts. And containers, while a powerful abstraction, say nothing about serverless computing or opinionated cloud services.
-
-
A Programming Model for the Cloud
-We now have an opportunity to reimagine what the next generation of cloud native software development will look like. This software will leverage the increasingly sophisticated public cloud capabilities: AI, machine learning, large scale data storage and science, and reimagined SaaS product architectures. Such software will not use the cloud as an afterthought. The winners will be those who enable new, compelling experiences, at dramatically lower cost structures, by using the core capabilities of the cloud in fundamental and intrinsic ways. The cloud will become an ever-present part of the application design, not an entirely separable layer, authored using a different suite of tools and techniques, managed by a distinct operations team operating at an arm's length.
-
+We now have an opportunity to reimagine what the next generation of cloud native software development will look like. This software will leverage the increasingly sophisticated public cloud capabilities: AI, machine learning, large scale data storage and science, and reimagined SaaS product architectures. Such software will not use the cloud as an afterthought. The winners will be those who enable new, compelling experiences, at dramatically lower cost structures, by using the core capabilities of the cloud in fundamental and intrinsic ways. The cloud will become an ever-present part of the application design, not an entirely separable layer, authored using a different suite of tools and techniques, managed by a distinct operations team operating at an arm's length.
Emerging CoLaDa Architectures
-In developing for the cloud, the question is not one of traditional infrastructure versus containers versus serverless versus hosted services. We believe in using the best tool for the job. Serverless functions can infinitely and rapidly scale event-driven systems with a low cost and ease of programming, while containers are great for bringing stateful apps to the cloud and scaling them out using your favorite container scheduler. The key is in getting all of these technologies to seamlessly interoperate with one another in harmony, using consistent programming models and management practices.
-
+In developing for the cloud, the question is not one of traditional infrastructure versus containers versus serverless versus hosted services. We believe in using the best tool for the job. Serverless functions can infinitely and rapidly scale event-driven systems with a low cost and ease of programming, while containers are great for bringing stateful apps to the cloud and scaling them out using your favorite container scheduler. The key is in getting all of these technologies to seamlessly interoperate with one another in harmony, using consistent programming models and management practices.
Code is the Best Config
+
As a case in point, consider configuration languages. They are unfamiliar to most developers and lack the same rigor developers apply to application code (such as code reusability, unit tests, and linting and static analysis). This almost always takes the form of JSON or YAML templating languages or, best case, special purpose DSLs that lack the full expressiveness of real languages. There remains a cultural divide between developers and DevOps that is in large part created by the fragmentation in programming tools. But it goes deeper than that. Most of us still think of gluing together virtual machines when we hear the word "infrastructure."
Despite increasing the level of abstraction in cloud software, "infrastructure" will in fact rise in importance to developers, just as developers care deeply about their target operating system's process and thread scheduling, memory and disk storage, and management and UI capabilities. It's easy to assume infrastructure goes away -- and indeed, for some programmers it will -- but a holistic approach must not try to hide its presence.
-
-
Finding a Lingua Franca for the Cloud
+
Newer cloud architectures are already resulting in a dramatic shift from coarse-grained cloud infrastructure -- virtual machines, for instance -- to a vast array of finer-grained CoLaDa resources -- containers, serverless functions, various data stores, security roles, and so on -- each of which is composed together to build larger systems out of smaller pieces. Because of this explosion, the approach to configuration languages that prevails to this day -- one of developers asking operators to glue together virtual machines and databases -- simply will not scale.
The key missing piece to taming this complexity is having lovable abstractions that allow for abstraction, reuse, and componentization.
@@ -68,7 +47,6 @@ The key missing piece to taming this complexity is having lovable abstractions t
A true cloud programming platform will offer a clear path to finally realizing the DevOps vision that our industry has made so much progress towards in the past decade. As with all software skills, practitioners will specialize in operational areas they know best and become industry influencers in their areas of expertise. The tools, however, will allow them to share their best practices in a reusable form, the same way thought leaders in, for example, machine learning have shared frameworks they have built. This allows us all to stand on the shoulders of giants, and to remove the hard divide between developers and operators that has discouraged collaboration, sharing of knowledge, and innovation. A common lingua franca is within our grasp.
-
-
Spin up CoLaDa with Pulumi
+
It is the dawn of a new age for all aspects of the software development lifecycle: cloud programs at every developer's fingertips. We look forward to playing our part in what promises to be one of largest industry transformations in our lifetimes.
diff --git a/data/newsroom.toml b/data/newsroom.toml
new file mode 100644
index 000000000000..e59c40cac638
--- /dev/null
+++ b/data/newsroom.toml
@@ -0,0 +1,65 @@
+[[releases]]
+date = "11th June 2019"
+title = "Pulumi Announces $15M in Series A Funding to Accelerate Development and Adoption of its Cloud Native Development Platform"
+summary = "Commercial offering of common language cloud programming platform enables deployment of any application to any cloud by any team."
+url = "https://info.pulumi.com/press-release/pulumi-announces-15m-in-series-a-funding-to-accelerate-development-and-adoption-of-its-cloud-native-development-platform"
+
+[[releases]]
+date = "22nd October 2018"
+title = "Pulumi Announces $15M in Series A Funding to Accelerate Development and Adoption of its Cloud Native Development Platform"
+summary = "Commercial offering of common language cloud programming platform enables deployment of any application to any cloud by any team."
+url = "https://info.pulumi.com/press-release/pulumi-announces-15m-in-series-a-funding-to-accelerate-development-and-adoption-of-its-cloud-native-development-platform"
+
+[[releases]]
+date = "12th September 2018"
+title = "Pulumi’s Cloud Native SDK Lets Teams Easily Define and Deliver Cloud Native Infrastructure as Code for Kubernetes in Any Cloud Using Real Languages"
+summary = "Company joins CNCF to accelerate cloud native programming models for Kubernetes."
+url = "https://info.pulumi.com/press-release/pulumi-cloud-native-sdk-delivers-cloud-native-infrastructure-as-code-for-kubernetes/"
+
+[[releases]]
+date = "18th June 2018"
+title = "Pulumi Launches Cloud Development Platform to Help Teams Get Code to the Cloud Faster"
+summary = "Company funded by Madrona Venture Group and Tola Capital to help companies accelerate cloud application development and infrastructure delivery. "
+url = "https://info.pulumi.com/press-release/pulumi-launches-cloud-development-platform-to-help-teams-get-code-to-the-cloud-faster/"
+
+[[coverage]]
+date = "22nd October 2018"
+title = "Pulumi raises $15M for its infrastructure as code platform"
+img = "/logos/press/techcrunch.png"
+url = "https://techcrunch.com/2018/10/22/pulumi-raises-15m-for-its-infrastructure-as-code-platform/"
+
+[[coverage]]
+date = "22nd October 2018"
+title = "Pulumi Launches Team Edition of Infrastructure as Code Platform"
+img = "/logos/press/eweek.jpg"
+url = "http://www.eweek.com/cloud/pulumi-launches-team-edition-of-infrastructure-as-code-platform/"
+
+[[coverage]]
+date = "22nd October 2018"
+title = "Pulumi Bridges The Gap Between Cloud-Native Development And Infrastructure As Code"
+img = "/logos/press/forbes.png"
+url = "https://www.forbes.com/sites/janakirammsv/2018/10/16/pulumi-bridges-the-gap-between-cloud-native-development-and-infrastructure-as-code/"
+
+[[coverage]]
+date = "12th September 2018"
+title = "Pulumi releases software-development kit to unlock the multicloud potential of Kubernetes"
+img = "/logos/press/geekwire.png"
+url = "https://www.geekwire.com/2018/pulumi-releases-software-development-kit-unlock-multicloud-potential-kubernetes/"
+
+[[coverage]]
+date = "19th June 2018"
+title = "Pulumi: Using Languages to Program Across Clouds."
+img = "/logos/press/newstack.png"
+url = "https://thenewstack.io/pulumi-using-languages-to-program-across-clouds/"
+
+[[coverage]]
+date = "18th June 2018"
+title = "Meet Pulumi, a Seattle-grown cloud startup that wants to be the development platform for the multicloud era."
+img = "/logos/press/geekwire.png"
+url = "https://www.geekwire.com/2018/meet-pulumi-seattle-grown-cloud-startup-wants-development-platform-multicloud-era/"
+
+[[coverage]]
+date = "18th June 2018"
+title = "Pulumi wants to let you manage your infrastructure with code."
+img = "/logos/press/techcrunch.png"
+url = "https://techcrunch.com/2018/06/18/pulumi-wants-to-let-you-manage-your-infrastructure-with-code/"
diff --git a/layouts/404.html b/layouts/404.html
index 04eec5b05f82..cf63be206d47 100644
--- a/layouts/404.html
+++ b/layouts/404.html
@@ -12,7 +12,7 @@
-
+
- Pulumi is reinventing how people build modern cloud applications and services,
- through a unique platform that combines deep systems and infrastructure innovation
- with elegant programming models and developer tools.
+ Pulumi is reinventing how people build modern cloud applications and services,
+ through a unique platform that combines deep systems and infrastructure innovation
+ with elegant programming models and developer tools.
Our team is a diverse and talented group of individuals, with backgrounds in
@@ -19,8 +19,8 @@
Want to help program the cloud?
systems, from companies from all corners of the software industry. Our culture is
one of technical excellence, passion for teamwork, and customer obsession.
+
Apply Now
+
+
-
Apply Now
-
-
{{ end }}
diff --git a/layouts/crosswalk/aws.html b/layouts/crosswalk/aws.html
new file mode 100644
index 000000000000..ba9ecb8fd9bc
--- /dev/null
+++ b/layouts/crosswalk/aws.html
@@ -0,0 +1,191 @@
+{{ define "hero" }}
+
+
+
+
Well-Architected Infrastructure as Code for AWS
+
+ The easiest way to AWS — from development to production.
+
+ Provision services that are Well-Architected by default. Benefit
+ from patterns that worked for customers who have gone to
+ production. Easy to get started, and easy to do the right thing.
+
+
+
+
+
Desktop to Production
+
+ Best in class productivity means you can rapidly deploy
+ applications and infrastructure, with the confidence that what you
+ build is production ready out-of-the-box.
+
+
+
+
+
Use Familiar Languages
+
+ Pulumi's unique approach to infrastructure as code uses familiar
+ languages you already know and love, meaning you can use your
+ favorite tools and engineering practices.
+
+
+
+
+
+
+
+
+
+
+
+
+ We've been happily using Pulumi’s EKS support for more than three months
+ now. Our team was looking for an end-to-end solution to tame the
+ complexity of Kubernetes on AWS and ensure we adhere to AWS best
+ practices. Pulumi’s Crosswalk effort has equipped our team to scale far
+ better than the alternative approaches of home-grown solutions, scripts
+ and DSLs. Our delivery is now automated and we can now deliver new
+ application and infrastructure features with much faster turn-around,
+ sometimes in just a few hours. Pulumi is a key contributor to our team’s
+ improvement in productivity.
+
+
+
Pankaj Dhingra, Senior Director of Cloud Engineering
+ Get up and running on "day one" with containers -- using Amazon
+ Elastic Container Service (ECS), including "Fargate" or Kubernetes
+ (EKS) -- or serverless -- using AWS Lambda or API Gateway. Benefit
+ from secure and reliable defaults, and customize only where you
+ need to.
+
+
+ With Pulumi's unique approach to infrastructure as code, you'll
+ focus more on code and business logic, and less on YAML or DSL
+ configuration languages.
+
+
+ // Create a load balanced ECS "Fargate" service.
+ import * as awsx from "@pulumi/awsx";
+
+ // Spin up two instances of NGINX on port 80.
+ const lb = new awsx.elasticloadbalancingv2.ApplicationListener("nginx", { port: 80 });
+ const nginx = new awsx.ecs.FargateService("nginx", {
+ taskDefinitionArgs: {
+ containers: {
+ nginx: {
+ image: "nginx",
+ memory: 128,
+ portMappings: [ lb ],
+ },
+ },
+ },
+ desiredCount: 2,
+ });
+
+ // Export the service's URL so that it's easy to access.
+ export const url = lb.endpoint.hostname;
+
+
+
+
+
+
+
+
+
+
+
+
Secure Infrastructure as Code
+
+ Create, manage, and integrate "day two and beyond" infrastructure
+ for security, networking, clusters, and monitoring. Instead of
+ relearning best practices time and time again, use hardened
+ packages that automatically encapsulate Well-Architected patterns
+ and practices.
+
+
+ Pulumi's unique approach to infrastructure as code means you can
+ leverage highly configurable and extensible components to enforce
+ best practices within your team.
+
// Create a new VPC with public, private, and isolated subnets.
+import * as awsx from "@pulumi/awsx";
+
+// Allocate a new VPC with a public and private subnet per AZ,
+// plus two isolated subnets without Internet access, one for our
+// DB instances and another for our Redis instances.
+const vpc = new awsx.ec2.Vpc("custom", {
+ subnets: [
+ { type: "public" },
+ { type: "private" },
+ { type: "isolated", name: "db" },
+ { type: "isolated", name: "redis" },
+ ],
+});
+
+// Export the VPC ID and subnet IDs for easy consumption:
+export const vpcId = vpc.id;
+export const vpcPrivateSubnetIds = vpc.privateSubnetIds;
+export const vpcPublicSubnetIds = vpc.publicSubnetIds;
+
- By using general purpose languages for infrastructure as code,
- you get all the benefits of real languages -- IDEs, abstractions and
- reuse thanks to functions, classes, and packages, debugging, testability,
- and more. The result is far less copy and paste and greater productivity,
- and it works the same way no matter which cloud you're targeting.
+
+
+
+
+ Cloud Native Infrastructure as Code
+
+
+ Provision infrastructure on any cloud using your favorite language.
-
-
-
Alternatives
-
- Other approaches use YAML, JSON, or bespoke DSLs that you need to
- master -- and convince your team to use. These "languages" fall short of
- general purpose languages, lacking abstractions and reuse, and reinvent
- familiar concepts like package managers. Worse, these solutions are usually
- unique to every given cloud that you need to target.
-
-
-
-
Community
-
- Pulumi's SDK is fully open source and extensible, enabling you to
- participate in a rich ecosystem of libraries that ease common tasks,
- ranging from containers to serverless to infrastructure, and everything
- in between. Languages and clouds are supported using an extensible
- plugin model, enabling public, private, and even hybrid cloud support.
+
+ By using general purpose languages for infrastructure as code,
+ you get all the benefits of real languages -- IDEs, abstractions and
+ reuse thanks to functions, classes, and packages, debugging, testability,
+ and more. The result is far less copy and paste and greater productivity,
+ and it works the same way no matter which cloud you're targeting.
+
+
+
+
Alternatives
+
+ Other approaches use YAML, JSON, or bespoke DSLs that you need to
+ master -- and convince your team to use. These "languages" fall short of
+ general purpose languages, lacking abstractions and reuse, and reinvent
+ familiar concepts like package managers. Worse, these solutions are usually
+ unique to every given cloud that you need to target.
+
+
+
+
Community
+
+ Pulumi's SDK is fully open source and extensible, enabling you to
+ participate in a rich ecosystem of libraries that ease common tasks,
+ ranging from containers to serverless to infrastructure, and everything
+ in between. Languages and clouds are supported using an extensible
+ plugin model, enabling public, private, and even hybrid cloud support.
+
Use the best of your chosen cloud -- containers, serverless, and
- managed infrastructure -- while also unleashing one consistent approach to software
- delivery no matter your cloud provider.
-
-
+{{ define "hero" }}
+
+
+
+
Modern Infrastructure as Code
+
+ Create, deploy, and manage infrastructure on any cloud using your
+ favorite language.
+
Flexibly solve a wide variety of tasks including scalable websites and APIs, event streaming and processing, all through multi-cloud and multi-language microservices.
Define cloud services and infrastructure in code, then continuously deploy. Correct issues in infrastructure automatically to return to the desired state.
Deploy and orchestrate cloud native container-based apps on Kubernetes, either on-premises or in the cloud. Use real code to define and deploy Kubernetes services.