Add Python Guestbook Component Example (pulumi#689)

aws-ts-stackreference/README.md

@@ -18,7 +18,7 @@ stacks via [StackReference](https://www.pulumi.com/docs/intro/concepts/organizin
  ```bash
  $ cd company
  $ npm install
- ````
+ ```
 
 1. Create a new stack:
 

kubernetes-py-guestbook/.gitignore

@@ -308,6 +308,7 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
+venv
 
 # Cake - Uncomment if you are using it
 # tools/**

kubernetes-py-guestbook/README.md

@@ -1,6 +1,6 @@
-[![Deploy](https://get.pulumi.com/new/button.svg)](https://app.pulumi.com/new?template=https://github.com/pulumi/examples/tree/master/kubernetes-py-guestbook/simple)
+[![Deploy](https://get.pulumi.com/new/button.svg)](https://app.pulumi.com/new?template=https://github.com/pulumi/examples/tree/master/kubernetes-ts-guestbook/components)
 
-# Simple Guestbook App
+# Simple and Component-based Kubernetes Guestbook Apps
 
 A port of the standard [Kubernetes Guestbook](https://kubernetes.io/docs/tutorials/stateless-application/guestbook/)
 to Pulumi. This example shows you how to build and deploy a simple, multi-tier web application using Kubernetes and
@@ -9,3 +9,11 @@ Docker, and consists of three components:
 * A single-instance Redis master to store guestbook entries
 * Multiple replicated Redis instances to serve reads
 * Multiple web frontend instances
+
+In this directory, you will find two variants of the Guestbook:
+
+1. [simple/](./simple) is a straight port of the original YAML.
+2. [components](./components) demonstrates benefits of using a real language, namely eliminating boilerplate through
+ the use of real component abstractions.
+
+Both examples provision the exact same Kubernetes Guestbook application, but showcase different aspects of Pulumi.

kubernetes-py-guestbook/components/Pulumi.yaml

@@ -0,0 +1,3 @@
+name: kubernetes-py-guestbook
+runtime: python
+description: Kubernetes Guestbook example based on https://kubernetes.io/docs/tutorials/stateless-application/guestbook/

kubernetes-py-guestbook/components/README.md

@@ -0,0 +1,88 @@
+[![Deploy](https://get.pulumi.com/new/button.svg)](https://app.pulumi.com/new)
+
+# Kubernetes Guestbook (with Components)
+
+A version of the [Kubernetes Guestbook](https://kubernetes.io/docs/tutorials/stateless-application/guestbook/)
+application using Pulumi. Unlike [the straight port of the original YAML](../simple), this variant
+leverages real code to eliminate boilerplate. A `ServiceDeployment` class is used that combines the common pattern
+of deploying a container image using a Kubernetes `Deployment`, and then scaling it using a `Service`.
+
+## Running the App
+
+Follow the steps in [Pulumi Installation](https://www.pulumi.com/docs/get-started/install/) and [Kubernetes Setup](https://www.pulumi.com/docs/intro/cloud-providers/kubernetes/setup/) to get Pulumi working with Kubernetes.
+
+Create a new stack:
+
+```sh
+$ pulumi stack init
+Enter a stack name: testbook
+```
+
+This example will attempt to expose the Guestbook application to the Internet with a `Service` of
+type `LoadBalancer`. Since minikube does not support `LoadBalancer`, the Guestbook application
+already knows to use type `ClusterIP` instead; all you need to do is to tell it whether you're
+deploying to minikube:
+
+```sh
+pulumi config set isMinikube <value>
+```
+
+Perform the deployment:
+
+```sh
+$ pulumi up
+Previewing update (guestbook):
+
+ Type Name Plan 
+ + pulumi:pulumi:Stack guestbook-easy-guestbook create 
+ + ├─ k8sx:component:ServiceDeployment frontend create 
+ + │ ├─ kubernetes:apps:Deployment frontend create 
+ + │ └─ kubernetes:core:Service frontend create 
+ + ├─ k8sx:component:ServiceDeployment redis-replica create 
+ + │ ├─ kubernetes:apps:Deployment redis-replica create 
+ + │ └─ kubernetes:core:Service redis-replica create 
+ + └─ k8sx:component:ServiceDeployment redis-master create 
+ + ├─ kubernetes:apps:Deployment redis-master create 
+ + └─ kubernetes:core:Service redis-master create 
+
+Resources:
+ + 10 to create
+
+Do you want to perform this update? yes
+Updating (guestbook):
+
+ Type Name Status 
+ + pulumi:pulumi:Stack guestbook-easy-guestbook created 
+ + ├─ k8sx:component:ServiceDeployment redis-master created 
+ + │ ├─ kubernetes:apps:Deployment redis-master created 
+ + │ └─ kubernetes:core:Service redis-master created 
+ + ├─ k8sx:component:ServiceDeployment frontend created 
+ + │ ├─ kubernetes:apps:Deployment frontend created 
+ + │ └─ kubernetes:core:Service frontend created 
+ + └─ k8sx:component:ServiceDeployment redis-replica created 
+ + ├─ kubernetes:apps:Deployment redis-replica created 
+ + └─ kubernetes:core:Service redis-replica created 
+
+Outputs:
+ frontend_ip: "10.105.48.30"
+
+Resources:
+ + 10 created
+
+Duration: 21s
+
+Permalink: https://app.pulumi.com/acmecorp/k8sjs-guestbook/updates/1
+```
+
+And finally - open the application in your browser to see the running application. If you're running
+macOS you can simply run:
+
+```sh
+open $(pulumi stack output frontend_ip)
+```
+
+> _Note_: minikube does not support type `LoadBalancer`; if you are deploying to minikube, make sure
+> to run `kubectl port-forward svc/frontend 8080:80` to forward the cluster port to the local
+> machine and access the service via `localhost:8080`.
+
+![Guestbook in browser](./imgs/guestbook.png)

kubernetes-py-guestbook/components/__main__.py

@@ -0,0 +1,39 @@
+# Copyright 2016-2020, Pulumi Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http:https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pulumi
+from service_deployment import ServiceDeployment
+
+# Minikube does not implement services of type `LoadBalancer`; require the user to specify if we're
+# running on minikube, and if so, create only services of type ClusterIP.
+config = pulumi.Config()
+isMinikube = config.get_bool("isMinikube")
+
+ServiceDeployment(
+ "redis-master",
+ image="k8s.gcr.io/redis:e2e",
+ ports=[6379])
+ServiceDeployment(
+ "redis-slave",
+ image="gcr.io/google_samples/gb-redisslave:v1",
+ ports=[6379])
+frontend = ServiceDeployment(
+ "frontend",
+ image="gcr.io/google-samples/gb-frontend:v4",
+ replicas=3,
+ ports=[80],
+ allocate_ip_address=True,
+ is_minikube=config.get_bool("isMinikube"))
+
+pulumi.export("frontend_ip", frontend.ip_address)

kubernetes-py-guestbook/components/requirements.txt

@@ -0,0 +1,2 @@
+pulumi>=2.0.0,<3.0.0
+pulumi-kubernetes>=2.0.0,<3.0.0

kubernetes-py-guestbook/components/service_deployment.py

@@ -0,0 +1,70 @@
+# Copyright 2016-2020, Pulumi Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http:https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import List
+
+import pulumi
+from pulumi import ResourceOptions, ComponentResource, Output
+from pulumi_kubernetes.apps.v1 import Deployment
+from pulumi_kubernetes.core.v1 import Service, Namespace
+
+
+class ServiceDeployment(ComponentResource):
+ deployment: Deployment
+ service: Service
+ ip_address: Output[str]
+
+ def __init__(self, name: str, image: str,
+ resources: dict = None, replicas: int = None,
+ ports: List[int] = None, allocate_ip_address: bool = None,
+ is_minikube: bool = None, opts: ResourceOptions = None):
+ super().__init__('k8sx:component:ServiceDeployment', name, {}, opts)
+
+ labels = {"app": name}
+ container = {
+ "name": name,
+ "image": image,
+ "resources": resources or {"requests": {"cpu": "100m", "memory": "100Mi"}},
+ "ports": [{"container_port": p} for p in ports] if ports else None,
+ }
+ self.deployment = Deployment(
+ name,
+ spec={
+ "selector": {"match_labels": labels},
+ "replicas": 1,
+ "template": {
+ "metadata": {"labels": labels},
+ "spec": {"containers": [container]},
+ },
+ },
+ opts=pulumi.ResourceOptions(parent=self))
+ self.service = Service(
+ name,
+ metadata={
+ "name": name,
+ "labels": self.deployment.metadata['labels'],
+ },
+ spec={
+ "ports": [{"port": p, "targetPort": p} for p in ports] if ports else None,
+ "selector": self.deployment.spec['template']['metadata']['labels'],
+ "type": ("ClusterIP" if is_minikube else "LoadBalancer") if allocate_ip_address else None,
+ },
+ opts=pulumi.ResourceOptions(parent=self))
+ if allocate_ip_address:
+ if is_minikube:
+ self.ip_address = self.service.spec['clusterIP']
+ else:
+ ingress=self.service.status['load_balancer']['ingress'][0]
+ self.ip_address = ingress.apply(lambda i: ingress["ip"] if "ip" in i else ingress['hostname'])
+ self.register_outputs({})