This sample application consists of two services: a "markdown editor" and a separate "markdown renderer". The environment variable, `EDITOR_UPSTREAM_RENDER_URL`, is used to point the "markdown editor" to the "markdown renderer".

Read more about how to deploy and work with these services in https://cloud.google.com/run/docs/tutorials/secure-services.

import json

import subprocess

from urllib import request

import uuid

import pytest

def services():

# Unique suffix to create distinct service names

suffix = uuid.uuid4().hex

# Build and Deploy Cloud Run Services

subprocess.run(

[

"gcloud",

"builds",

"submit",

"--substitutions",

f"_SUFFIX={suffix}",

"--config",

"e2e_test_setup.yaml",

"--quiet",

], check=True

)

# Get the URL for the editor and the token

editor = subprocess.run(

[

"gcloud",

"run",

"--platform=managed",

"--region=us-central1",

"services",

"describe",

f"editor-{suffix}",

"--format=value(status.url)",

],

stdout=subprocess.PIPE,

check=True

).stdout.strip()

token = subprocess.run(

["gcloud", "auth", "print-identity-token"], stdout=subprocess.PIPE,

check=True

).stdout.strip()

yield editor, token

subprocess.run(

["gcloud", "run", "services", "delete", f"editor-{suffix}",

"--platform", "managed", "--region", "us-central1", "--quiet"],

check=True

)

subprocess.run(

["gcloud", "run", "services", "delete", f"renderer-{suffix}",

"--platform", "managed", "--region", "us-central1", "--quiet"],

check=True

)

def test_end_to_end(services):

editor = services[0].decode() + "/render"

token = services[1].decode()

data = json.dumps({"data": "**strong text**"})

req = request.Request(

editor,

data=data.encode(),

headers={

"Authorization": f"Bearer {token}",

"Content-Type": "application/json",

},

)

response = request.urlopen(req)

assert response.status == 200

body = response.read()

assert "<p><strong>strong text</strong></p>" in body.decode()

steps:

- # Build the renderer image

name: gcr.io/cloud-builders/docker:latest

args: ['build', '--tag=gcr.io/$PROJECT_ID/renderer-${_SUFFIX}', 'renderer/.']

- # Push the container image to Container Registry

name: gcr.io/cloud-builders/docker

args: ['push', 'gcr.io/$PROJECT_ID/renderer-${_SUFFIX}']

- # Deploy to Cloud Run

name: gcr.io/cloud-builders/gcloud

args:

- run

- deploy

- renderer-${_SUFFIX}

- --image

- gcr.io/$PROJECT_ID/renderer-${_SUFFIX}

- --region

- us-central1

- --platform

- managed

- --no-allow-unauthenticated

- # Get the Renderer URL and save to workspace

name: gcr.io/cloud-builders/gcloud

entrypoint: /bin/bash

args:

- -c

- |

- # Build the editor image

name: gcr.io/cloud-builders/docker:latest

args: ['build', '--tag=gcr.io/$PROJECT_ID/editor-${_SUFFIX}', 'editor/.']

- # Push the container image to Container Registry

name: gcr.io/cloud-builders/docker

args: ['push', 'gcr.io/$PROJECT_ID/editor-${_SUFFIX}']

- # Deploy with renderer url environment variable

name: gcr.io/cloud-builders/gcloud

entrypoint: /bin/bash

args:

- -c

- "gcloud run deploy editor-${_SUFFIX} --image gcr.io/$PROJECT_ID/editor-${_SUFFIX} \

images:

- 'gcr.io/$PROJECT_ID/renderer-${_SUFFIX}'

- 'gcr.io/$PROJECT_ID/editor-${_SUFFIX}'

FROM python:3.8-slim

COPY requirements.txt .

RUN pip install -r requirements.txt

ENV APP_HOME /app

WORKDIR $APP_HOME

COPY . .

CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

from flask import Flask, render_template, request

import os

import render

app = Flask(__name__)

def index():

# Render the default template

f = open("templates/markdown.md")

return render_template("index.html", default=f.read())

def render_handler():

body = request.get_json()

if not body:

raise Exception("Invalid JSON")

data = body["data"]

parsed_markdown = render.new_request(data)

return parsed_markdown

if __name__ == "__main__":

PORT = int(os.getenv("PORT")) if os.getenv("PORT") else 8080

# This is used when running locally. Gunicorn is used to run the

# application on Cloud Run. See entrypoint in Dockerfile.

app.run(host="127.0.0.1", port=PORT, debug=True)

import main

import os

import json

import pytest

def client():

main.app.testing = True

return main.app.test_client()

def test_editor_handler(client):

os.environ["EDITOR_UPSTREAM_RENDER_URL"] = "http://testing.local"

r = client.get("/")

body = r.data.decode()

assert r.status_code == 200

assert "<title>Markdown Editor</title>" in body

assert "This UI allows a user to write Markdown text" in body

def test_render_handler_errors(client):

r = client.get("/render")

assert r.status_code == 405

with pytest.raises(Exception) as e:

client.post("/render", data="**markdown**")

assert "Invalid JSON" in str(e.value)

def test_missing_upstream_url(client):

del os.environ["EDITOR_UPSTREAM_RENDER_URL"]

with pytest.raises(Exception) as e:

client.post("/render",

data=json.dumps({"data": "**strong text**"}),

headers={"Content-Type": "application/json"})

assert "EDITOR_UPSTREAM_RENDER_URL missing" in str(e.value)

import os

import sys

import urllib

def new_request(data):

"""

url = os.environ.get("EDITOR_UPSTREAM_RENDER_URL")

if not url:

raise Exception("EDITOR_UPSTREAM_RENDER_URL missing")

unauthenticated = os.environ.get("EDITOR_UPSTREAM_UNAUTHENTICATED", False)

req = urllib.request.Request(url, data=data.encode())

if not unauthenticated:

token = get_token(url)

req.add_header("Authorization", f"Bearer {token}")

sys.stdout.flush()

response = urllib.request.urlopen(req)

return response.read()

def get_token(url):

"""

token_url = (

f"http://metadata.google.internal/computeMetadata/v1/instance/"

f"service-accounts/default/identity?audience={url}"

)

token_req = urllib.request.Request(

token_url, headers={"Metadata-Flavor": "Google"}

)

token_response = urllib.request.urlopen(token_req)

token = token_response.read()

return token.decode()

pytest==5.3.2