Quickstart: Build and Deploy

Go

1. Create a new directory named helloworld-go and change directory into it:

   mkdir helloworld-go
   cd helloworld-go
   

2. Initialize a go.mod file to declare the go module:

   go mod init helloworld-go
   

3. Create a new file named helloworld.go and paste the following code into it:

   docs/serving/samples/hello-world/helloworld-go/helloworld.go

   package main
   
   import (
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   )
   
   func handler(w http.ResponseWriter, r *http.Request) {
   	log.Print("Hello world received a request.")
   	target := os.Getenv("TARGET")
   	if target == "" {
   		target = "World"
   	}
   	fmt.Fprintf(w, "Hello %s!\n", target)
   }
   
   func main() {
   	log.Print("Hello world sample started.")
   
   	http.HandleFunc("/", handler)
   
   	port := os.Getenv("PORT")
   	if port == "" {
   		port = "8080"
   	}
   
   	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
   }
   

   This code creates a basic web server that listens on the port defined by the PORT environment variable.

Your app is finished and ready to be containerized and uploaded to Container Registry.

Node.js

1. Create a new directory named helloworld-nodejs and change directory into it:

   mkdir helloworld-nodejs
   cd helloworld-nodejs
   

2. Create a package.json file with the following contents:

   docs/serving/samples/hello-world/helloworld-nodejs/package.json

   {
     "name": "knative-serving-helloworld",
     "version": "1.0.0",
     "description": "Simple hello world sample in Node",
     "main": "index.js",
     "scripts": {
       "start": "node index.js"
     },
     "author": "",
     "license": "Apache-2.0",
     "dependencies": {
       "express": "^4.16.4"
     }
   }
   

3. In the same directory, create a index.js file, and copy the following lines into it:

   docs/serving/samples/hello-world/helloworld-nodejs/index.js

   const express = require('express');
   const app = express();
   
   app.get('/', (req, res) => {
     console.log('Hello world received a request.');
   
     const target = process.env.TARGET || 'World';
     res.send(`Hello ${target}!`);
   });
   
   const port = process.env.PORT || 8080;
   app.listen(port, () => {
     console.log('Hello world listening on port', port);
   });
   

   This code creates a basic web server that listens on the port defined by the PORT environment variable.

Your app is finished and ready to be containerized and uploaded to Container Registry.

Python

1. Create a new directory named helloworld-python and change directory into it:

   mkdir helloworld-python
   cd helloworld-python
   

2. Create a file named app.py and paste the following code into it:

   docs/serving/samples/hello-world/helloworld-python/app.py

   import os
   
   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello_world():
       target = os.environ.get('TARGET', 'World')
       return 'Hello {}!\n'.format(target)
   
   if __name__ == "__main__":
       app.run(debug=True,host='0.0.0.0',port=int(os.environ.get('PORT', 8080)))
   

   This code responds to requests with our "Hello World" greeting. HTTP handling is done by a Gunicorn web server in the container. When directly invoked for local use, this code creates a basic web server that listens on the port defined by the PORT environment variable.

Your app is finished and ready to be containerized and uploaded to Container Registry.

Java

Create a Spring Boot application.

1. From the console, create a new empty web project using the cURL and unzip commands:

   curl https://start.spring.io/starter.zip \
       -d dependencies=web \
       -d javaVersion=1.8 \
       -d bootVersion=2.1.3.RELEASE \
       -d name=helloworld \
       -d artifactId=helloworld \
       -d baseDir=helloworld \
       -o helloworld.zip
   unzip helloworld.zip
   cd helloworld
   

   This creates a Spring Boot project.

2. Update the HelloworldApplication class in src/main/java/com/example/helloworld/HelloworldApplication.java by adding a @RestController to handle the / mapping and also add a @Value field to provide the TARGET environment variable:

   docs/serving/samples/hello-world/helloworld-java-spring/src/main/java/com/example/helloworld/HelloworldApplication.java

   package com.example.helloworld;
   
   import org.springframework.beans.factory.annotation.Value;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @SpringBootApplication
   public class HelloworldApplication {
   
   	@Value("${TARGET:World}")
   	String target;
   
   	@RestController
   	class HelloworldController {
   		@GetMapping("/")
   		String hello() {
   			return "Hello " + target + "!";
   		}
   	}
   
   	public static void main(String[] args) {
   		SpringApplication.run(HelloworldApplication.class, args);
   	}
   }
   

   This code creates a basic web server that listens on the port defined by the PORT environment variable.

Your app is finished and ready to be containerized and uploaded to Container Registry.

To deploy Java to Cloud Run with other frameworks, review the Knative samples for Spark and Vert.x.

C#

1. Install .NET Core SDK 3.0. Note that we only need to do this to create the new web project in the next step: the Dockerfile, which is described later, will load all dependencies into the container.

2. From the console, create a new empty web project using the dotnet command:

   dotnet new web -o helloworld-csharp
   

3. Change directory to helloworld-csharp.

4. Update the CreateWebHostBuilder definition in Program.cs to listen on the port defined by the PORT environment variable:

   docs/serving/samples/hello-world/helloworld-csharp/Program.cs

   using System;
   using Microsoft.AspNetCore.Hosting;
   using Microsoft.Extensions.Hosting;
   
   namespace helloworld_csharp
   {
       public class Program
       {
           public static void Main(string[] args)
           {
               CreateHostBuilder(args).Build().Run();
           }
   
           public static IHostBuilder CreateHostBuilder(string[] args)
           {
               string port = Environment.GetEnvironmentVariable("PORT") ?? "8080";
               string url = String.Concat("http://0.0.0.0:", port);
   
               return Host.CreateDefaultBuilder(args)
                   .ConfigureWebHostDefaults(webBuilder =>
                   {
                       webBuilder.UseStartup<Startup>().UseUrls(url);
                   });
           }
       }
   }

   This code creates a basic web server that listens on the port defined by the PORT environment variable.

5. Create a file named Startup.cs and paste the following code into it:

   docs/serving/samples/hello-world/helloworld-csharp/Startup.cs

   using System;
   using Microsoft.AspNetCore.Builder;
   using Microsoft.AspNetCore.Hosting;
   using Microsoft.AspNetCore.Http;
   using Microsoft.Extensions.DependencyInjection;
   using Microsoft.Extensions.Hosting;
   
   namespace helloworld_csharp
   {
       public class Startup
       {
           // This method gets called by the runtime. Use this method to add services to the container.
           // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
           public void ConfigureServices(IServiceCollection services)
           {
           }
   
           // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
           public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
           {
               if (env.IsDevelopment())
               {
                   app.UseDeveloperExceptionPage();
               }
   
               app.UseRouting();
   
               app.UseEndpoints(endpoints =>
               {
                   endpoints.MapGet("/", async context =>
                   {
                       var target = Environment.GetEnvironmentVariable("TARGET") ?? "World";
                       await context.Response.WriteAsync($"Hello {target}!\n");
                   });
               });
           }
       }
   }

   This code responds to requests with our "Hello World" greeting.

Your app is finished and ready to be containerized and uploaded to Container Registry.

PHP

1. Create a new directory named helloworld-php and change directory into it:

   mkdir helloworld-php
   cd helloworld-php
   

2. Create a file named index.php and paste the following code into it:

   docs/serving/samples/hello-world/helloworld-php/index.php

   <?php
   $target = getenv('TARGET', true) ?: 'World';
   echo sprintf("Hello %s!", $target);
   

   This code responds to requests with our "Hello World" greeting. HTTP handling is done by an Apache web server in the container.

Your app is finished and ready to be containerized and uploaded to Container Registry.

Ruby

1. Create a new directory named helloworld-ruby and change directory into it:

   mkdir helloworld-ruby
   cd helloworld-ruby
   

2. Create a file named app.rb and paste the following code into it:

   docs/serving/samples/hello-world/helloworld-ruby/app.rb

   require 'sinatra'
   
   set :bind, '0.0.0.0'
   
   get '/' do
     target = ENV['TARGET'] || 'World'
     "Hello #{target}!\n"
   end
   

   This code creates a basic web server that listens on the port defined by the PORT environment variable.

3. Create a file nameGemfile and copy the following into it:

   docs/serving/samples/hello-world/helloworld-ruby/Gemfile

   source 'https://rubygems.org'
   
   gem 'sinatra'
   gem 'rack', '>= 2.0.6'
   

4. If you don't have Bundler 2.0 or greater installed, install Bundler.

5. Generate a Gemfile.lock file by running:

   bundle install

Your app is finished and ready to be containerized and uploaded to Container Registry.

Shell

1. Create a new directory named helloworld-shell and change directory into it:

   mkdir helloworld-shell
   cd helloworld-shell
   

2. Create a script.sh file with the following contents:

   docs/serving/samples/hello-world/helloworld-shell/script.sh

   #!/bin/sh
   echo Hello ${TARGET:=World}!
   
   
   

   In order to execute this shell script on every incoming requests, this sample uses a small Go program that starts a basic web server and listen on the port defined by the PORT environment variable.

3. Create a invoke.go file with the following contents:

   docs/serving/samples/hello-world/helloworld-shell/invoke.go

   package main
   
   import (
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   	"os/exec"
   )
   
   func handler(w http.ResponseWriter, r *http.Request) {
   	cmd := exec.CommandContext(r.Context(), "/bin/sh", "script.sh")
   	cmd.Stderr = os.Stderr
   	out, err := cmd.Output()
   	if err != nil {
   		w.WriteHeader(500)
   	}
   	w.Write(out)
   }
   
   func main() {
   	http.HandleFunc("/", handler)
   
   	port := os.Getenv("PORT")
   	if port == "" {
   		port = "8080"
   	}
   
   	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
   }
   

Your app is finished and ready to be containerized and uploaded to Container Registry.

Other

Cloud Run supports most languages. For simple samples in languages other than the ones in this table, see the following:

• Kotlin
• Swift
• Dart
• Rust
• Elixir
• Other

However, in all of these samples, ignore and omit the material about service.yaml and Docker Hub, because Cloud Run does not use these.

Go

# Use the official Golang image to create a build artifact.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.13 as builder

# Create and change to the app directory.
WORKDIR /app

# Retrieve application dependencies.
# This allows the container build to reuse cached dependencies.
COPY go.* ./
RUN go mod download

# Copy local code to the container image.
COPY . ./

# Build the binary.
RUN CGO_ENABLED=0 GOOS=linux go build -mod=readonly -v -o server

# Use the official Alpine image for a lean production container.
# https://hub.docker.com/_/alpine
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM alpine:3
RUN apk add --no-cache ca-certificates

# Copy the binary to the production image from the builder stage.
COPY --from=builder /app/server /server

# Run the web service on container startup.
CMD ["/server"]

Node.js

# Use the official lightweight Node.js 12 image.
# https://hub.docker.com/_/node
FROM node:12-slim

# Create and change to the app directory.
WORKDIR /usr/src/app

# Copy application dependency manifests to the container image.
# A wildcard is used to ensure both package.json AND package-lock.json are copied.
# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./

# Install production dependencies.
RUN npm install --only=production

# Copy local code to the container image.
COPY . ./

# Run the web service on container startup.
CMD [ "npm", "start" ]

Add a .dockerignore file to exclude files from your container image. To exclude files from being uploaded to Cloud Build, add an additional .gcloudignore file.

Dockerfile
README.md
node_modules
npm-debug.log

Python

The Python Dockerfile starts a Gunicorn web server that listens on the port defined by the PORT environment variable:

# Use the official lightweight Python image.
# https://hub.docker.com/_/python
FROM python:3.7-slim

# Copy local code to the container image.
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./

# Install production dependencies.
RUN pip install Flask gunicorn

# Run the web service on container startup. Here we use the gunicorn
# webserver, with one worker process and 8 threads.
# For environments with multiple CPU cores, increase the number of workers
# to be equal to the cores available.
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 app:app

Add a .dockerignore file to exclude files from your container image. To exclude files from being uploaded to Cloud Build, add an additional .gcloudignore file.

Dockerfile
README.md
*.pyc
*.pyo
*.pyd
__pycache__

Java

# Use the official maven/Java 8 image to create a build artifact.
# https://hub.docker.com/_/maven
FROM maven:3.5-jdk-8-alpine as builder

# Copy local code to the container image.
WORKDIR /app
COPY pom.xml .
COPY src ./src

# Build a release artifact.
RUN mvn package -DskipTests

# Use AdoptOpenJDK for base image.
# It's important to use OpenJDK 8u191 or above that has container support enabled.
# https://hub.docker.com/r/adoptopenjdk/openjdk8
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM adoptopenjdk/openjdk8:jdk8u202-b08-alpine-slim

# Copy the jar to the production image from the builder stage.
COPY --from=builder /app/target/helloworld-*.jar /helloworld.jar

# Run the web service on container startup.
CMD ["java","-Djava.security.egd=file:/dev/./urandom","-Dserver.port=${PORT}","-jar","/helloworld.jar"]

C#

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/core/sdk:3.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out


# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/core/aspnet:3.0-alpine AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "helloworld-csharp.dll"]

Add a .dockerignore file to exclude files from your container image. To exclude files from being uploaded to Cloud Build, add an additional .gcloudignore file.

Dockerfile
README.md
**/obj/
**/bin/

PHP

The PHP Dockerfile starts an Apache web server that listens on the port defined by the PORT environment variable:

# Use the official PHP 7.3 image.
# https://hub.docker.com/_/php
FROM php:7.3-apache

# Copy local code to the container image.
COPY index.php /var/www/html/

# Use the PORT environment variable in Apache configuration files.
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://hub.docker.com/_/php#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

Add a .dockerignore file to exclude files from your container image. To exclude files from being uploaded to Cloud Build, add an additional .gcloudignore file.

Dockerfile
README.md
vendor

Ruby

# Use the official lightweight Ruby image.
# https://hub.docker.com/_/ruby
FROM ruby:2.5-slim

# Install production dependencies.
WORKDIR /usr/src/app
COPY Gemfile Gemfile.lock ./
ENV BUNDLE_FROZEN=true
RUN bundle install

# Copy local code to the container image.
COPY . ./

# Run the web service on container startup.
CMD ["ruby", "./app.rb"]

Shell

# Use the offical Golang image to create a build artifact.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.12 as builder

# Copy local code to the container image.
WORKDIR /go/src/github.com/knative/docs/helloworld-shell
COPY invoke.go .

# Build the command inside the container.
# (You may fetch or manage dependencies here,
# either manually or with a tool like "godep".)
RUN CGO_ENABLED=0 GOOS=linux go build -v -o invoke

# The official Alpine base image
# https://hub.docker.com/_/alpine
# Use a Docker multi-stage build to create a lean production image.
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM alpine:3.10

# Copy Go binary
COPY --from=builder /go/src/github.com/knative/docs/helloworld-shell/invoke /invoke
COPY script.sh .

# Run the web service on container startup.
CMD ["/invoke"]

Other

Cloud Run supports most languages. For sample Dockerfiles in languages other than the ones in this table, see the following:

• Kotlin
• Swift
• Dart
• Rust
• Elixir
• Other

However, in those samples, ignore and omit the material about service.yaml and Docker Hub, because Cloud Run does not use these.