Kurzanleitung: Erstellen und Bereitstellen


// Sample run-helloworld is a minimal Cloud Run service.
package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	log.Print("starting server...")
	http.HandleFunc("/", handler)

	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("defaulting to port %s", port)
	}

	// Start HTTP server.
	log.Printf("listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

func handler(w http.ResponseWriter, r *http.Request) {
	name := os.Getenv("NAME")
	if name == "" {
		name = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", name)
}

Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Node.js

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld
cd helloworld
```

Erstellen Sie eine package.json-Datei mit folgendem Inhalt:

run/helloworld/package.json

{
  "name": "helloworld",
  "description": "Simple hello world sample in Node",
  "version": "1.0.0",
  "private": true,
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "mocha test/index.test.js --exit",
    "system-test": "NAME=Cloud mocha test/system.test.js --timeout=180000",
    "lint": "eslint '**/*.js'",
    "fix": "eslint --fix '**/*.js'"
  },
  "engines": {
    "node": ">= 12.0.0"
  },
  "author": "Google LLC",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.17.1"
  },
  "devDependencies": {
    "google-auth-library": "^6.1.3",
    "got": "^11.0.0",
    "mocha": "^8.0.0",
    "supertest": "^6.0.0"
  }
}

Erstellen Sie im selben Verzeichnis eine index.js-Datei und kopieren Sie die folgenden Zeilen hinein:

run/helloworld/index.js

run/helloworld/src/main/java/com/example/helloworld/HelloworldApplication.java

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  const name = process.env.NAME || 'World';
  res.send(`Hello ${name}!`);
});

const port = process.env.PORT || 8080;
app.listen(port, () => {
  console.log(`helloworld: listening on port ${port}`);
});

Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Python

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld
cd helloworld
```
Erstellen Sie eine Datei mit dem Namen main.py und fügen Sie den folgenden Code in diese ein:

run/helloworld/main.py

Auf GitHub ansehen Feedback
```
import os

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    name = os.environ.get("NAME", "World")
    return "Hello {}!".format(name)

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
```
Dieser Code antwortet auf Anfragen mit der Begrüßung „Hello World“. Die HTTP-Verarbeitung erfolgt über einen Gunicorn-Webserver im Container. Wenn dieser Code direkt für die lokale Verwendung aufgerufen wird, erstellt er einen einfachen Webserver, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Java

Erstellen Sie eine Spring Boot-Anwendung.

Erstellen Sie über die Konsole mit den Befehlen "cURL" und "unzip" ein neues, leeres Webprojekt:
```
curl https://start.spring.io/starter.zip \
    -d dependencies=web \
    -d javaVersion=1.8 \
    -d bootVersion=2.3.3.RELEASE \
    -d name=helloworld \
    -d artifactId=helloworld \
    -d baseDir=helloworld \
    -o helloworld.zip
unzip helloworld.zip
cd helloworld
```
Dadurch wird ein Spring Boot-Projekt erstellt.

Verwenden Sie zum Erstellen des Projekts eine der folgenden Befehlszeilen oder optional Spring Initializr (Konfiguration vorab geladen), um den vorstehenden cURL-Befehl in Microsoft Windows nutzen zu können:
- WSL (bevorzugt)
- cygwin

Aktualisieren Sie die Klasse HelloworldApplication in src/main/java/com/example/helloworld/HelloworldApplication.java. Fügen Sie dazu einen @RestController ein, um die /-Zuordnung zu verarbeiten. Fügen Sie außerdem ein @Value-Feld hinzu, um die-Umgebungsvariable „NAME“ bereitzustellen:

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


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("${NAME:World}")
  String name;

  @RestController
  class HelloworldController {
    @GetMapping("/")
    String hello() {
      return "Hello " + name + "!";
    }
  }

  public static void main(String[] args) {
    SpringApplication.run(HelloworldApplication.class, args);
  }
}

Legen Sie den Serverport fest, der durch die in application.properties durch die Umgebungsvariable „PORT“ definiert werden soll:

run/helloworld/src/main/resources/application.properties

Auf GitHub ansehen Feedback
```
server.port=${PORT:8080}
```

Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Wenn Sie Java mit anderen Frameworks für Cloud Run bereitstellen möchten, sehen Sie sich die Knative-Beispiele für Spark und Vert.x an.

C#

Installieren Sie das .NET Core SDK 3.1. Dies ist nur erforderlich, damit wir im nächsten Schritt das neue Webprojekt erstellen können; das weiter unten beschriebene Dockerfile lädt dann später alle Abhängigkeiten in den Container.
Erstellen Sie über die Konsole mit dem Befehl "dotnet" ein neues, leeres Webprojekt:
```
dotnet new web -o helloworld-csharp
```
Ändern Sie das Verzeichnis in helloworld-csharp.

Aktualisieren Sie die CreateHostBuilder-Definition in Program.cs, um den Port zu überwachen, der durch die Umgebungsvariable PORT definiert ist:

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);
                });
        }
    }
}

Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Erstellen Sie eine Datei mit dem Namen Startup.cs und fügen Sie den folgenden Code in diese ein:

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");
                });
            });
        }
    }
}

Dieser Code antwortet auf Anfragen mit der Begrüßung „Hello World“.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

C++

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-cpp und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld-cpp
cd helloworld-cpp
```

Erstellen Sie eine neue Datei mit dem Namen CMakeLists.txt und fügen Sie dort den folgenden Code ein:

cloud-run-hello-world/CMakeLists.txt

cmake_minimum_required(VERSION 3.10)

# Define the project name and where to report bugs.
set(PACKAGE_BUGREPORT "https://github.com/GoogleCloudPlatform/cpp-samples/issues")
project(Docker-Run-C++ CXX C)

# Configure the Compiler options, we will be using C++17 features.
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Boost 1.66 REQUIRED COMPONENTS program_options)
find_package(Threads)

# When using static libraries the FindgRPC.cmake module does not define the
# correct dependencies (OpenSSL::Crypto, c-cares, etc) for gRPC::grpc.
# Explicitly listing these dependencies avoids the undefined symbols problems.
add_executable(cloud_run_hello cloud_run_hello.cc)
target_link_libraries(cloud_run_hello PRIVATE Boost::headers
                                              Boost::program_options
    Threads::Threads)

include(GNUInstallDirs)
install(TARGETS cloud_run_hello RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

Erstellen Sie eine neue Datei mit dem Namen cloud_run_hello.cpp und fügen Sie dort den folgenden Code ein:

cloud-run-hello-world/cloud_run_hello.cc

#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/strand.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/program_options.hpp>
#include <cstdlib>
#include <iostream>
#include <optional>
#include <thread>

namespace be = boost::beast;
namespace asio = boost::asio;
namespace po = boost::program_options;
using tcp = boost::asio::ip::tcp;

po::variables_map parse_args(int& argc, char* argv[]) {
  // Initialize the default port with the value from the "PORT" environment
  // variable or with 8080.
  auto port = [&]() -> std::uint16_t {
    auto env = std::getenv("PORT");
    if (env == nullptr) return 8080;
    auto value = std::stoi(env);
    if (value < std::numeric_limits<std::uint16_t>::min() ||
        value > std::numeric_limits<std::uint16_t>::max()) {
      std::ostringstream os;
      os << "The PORT environment variable value (" << value
         << ") is out of range.";
      throw std::invalid_argument(std::move(os).str());
    }
    return static_cast<std::uint16_t>(value);
  }();

  // Parse the command-line options.
  po::options_description desc("Server configuration");
  desc.add_options()
      //
      ("help", "produce help message")
      //
      ("address", po::value<std::string>()->default_value("0.0.0.0"),
       "set listening address")
      //
      ("port", po::value<std::uint16_t>()->default_value(port),
       "set listening port");

  po::variables_map vm;
  po::store(po::parse_command_line(argc, argv, desc), vm);
  po::notify(vm);
  if (vm.count("help")) {
    std::cout << desc << "\n";
  }
  return vm;
}

int main(int argc, char* argv[]) try {
  po::variables_map vm = parse_args(argc, argv);

  if (vm.count("help")) return 0;

  auto address = asio::ip::make_address(vm["address"].as<std::string>());
  auto port = vm["port"].as<std::uint16_t>();
  std::cout << "Listening on " << address << ":" << port << std::endl;

  auto handle_session = [](tcp::socket socket) {
    auto report_error = [](be::error_code ec, char const* what) {
      std::cerr << what << ": " << ec.message() << "\n";
    };

    be::error_code ec;
    for (;;) {
      be::flat_buffer buffer;

      // Read a request
      be::http::request<be::http::string_body> request;
      be::http::read(socket, buffer, request, ec);
      if (ec == be::http::error::end_of_stream) break;
      if (ec) return report_error(ec, "read");

      // Send the response
      // Respond to any request with a "Hello World" message.
      be::http::response<be::http::string_body> response{be::http::status::ok,
                                                         request.version()};
      response.set(be::http::field::server, BOOST_BEAST_VERSION_STRING);
      response.set(be::http::field::content_type, "text/plain");
      response.keep_alive(request.keep_alive());
      std::string greeting = "Hello ";
      auto const* target = std::getenv("TARGET");
      greeting += target == nullptr ? "World" : target;
      greeting += "\n";
      response.body() = std::move(greeting);
      response.prepare_payload();
      be::http::write(socket, response, ec);
      if (ec) return report_error(ec, "write");
    }
    socket.shutdown(tcp::socket::shutdown_send, ec);
  };

  asio::io_context ioc{/*concurrency_hint=*/1};
  tcp::acceptor acceptor{ioc, {address, port}};
  for (;;) {
    auto socket = acceptor.accept(ioc);
    if (!socket.is_open()) break;
    // Run a thread per-session, transferring ownership of the socket
    std::thread{handle_session, std::move(socket)}.detach();
  }

  return 0;
} catch (std::exception const& ex) {
  std::cerr << "Standard exception caught " << ex.what() << '\n';
  return 1;
}

Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

PHP

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-php und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld-php
cd helloworld-php
```
Erstellen Sie eine Datei mit dem Namen index.php und fügen Sie den folgenden Code in diese ein:

run/helloworld/index.php

Auf GitHub ansehen Feedback
```
$name = getenv('NAME', true) ?: 'World';
echo sprintf('Hello %s!', $name);
```
Dieser Code antwortet auf Anfragen mit der Begrüßung „Hello World“. Die HTTP-Verarbeitung erfolgt über einen Apache-Webserver im Container.

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Ruby

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld
cd helloworld
```
Erstellen Sie eine Datei mit dem Namen app.rb und fügen Sie den folgenden Code in diese ein:

run/helloworld/app.rb

Auf GitHub ansehen Feedback
```
require "sinatra"

set :bind, "0.0.0.0"
port = ENV["PORT"] || "8080"
set :port, port

get "/" do
  name = ENV["NAME"] || "World"
  "Hello #{name}!"
end
```
Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

Erstellen Sie eine Datei namens Gemfile und kopieren Sie Folgendes hinein:

run/helloworld/Gemfile

source "https://rubygems.org"

gem "sinatra", "~>2.0"

group :test do
  gem "rack-test"
  gem "rest-client"
  gem "rspec"
  gem "rspec_junit_formatter"
  gem "rubysl-securerandom"
end

Wenn Bundler 2.0 oder höher nicht installiert ist, installieren Sie Bundler.
Erstellen Sie mit diesem Befehl eine Gemfile.lock-Datei:

bundle install

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Shell

Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld-shell und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:
```
mkdir helloworld-shell
cd helloworld-shell
```
Erstellen Sie eine script.sh-Datei mit folgendem Inhalt:

helloworld-shell/script.sh

Auf GitHub ansehen Feedback
```
set -e
echo "Hello ${NAME:-World}!"
```
In diesem Beispiel wird das Shell-Skript mithilfe eines kleinen Go-Programms, das einen einfachen Webserver startet und den durch die Umgebungsvariable PORT definierten Port überwacht, für alle eingehenden Anfragen ausgeführt.

Erstellen Sie eine invoke.go-Datei mit folgendem Inhalt:

helloworld-shell/invoke.go


// Sample helloworld-shell is a Cloud Run shell-script-as-a-service.
package main

import (
	"log"
	"net/http"
	"os"
	"os/exec"
)

func main() {
	http.HandleFunc("/", scriptHandler)

	// Determine port for HTTP service.
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}

	// Start HTTP server.
	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

func scriptHandler(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)
}

Die Anwendung ist jetzt fertig und kann in einen Container verlagert und dann in Container Registry hochgeladen werden.

Andere

Cloud Run unterstützt die meisten Sprachen. Einfache Beispiele für Sprachen, die in dieser Tabelle nicht aufgeführt sind, finden Sie unter folgenden Links:

Überspringen Sie bei diesen Beispielen jedoch die Informationen zu service.yaml und Docker Hub, da diese Datei und diese Bibliothek in Cloud Run nicht verwendet werden.

Anwendung containerisieren und in Container Registry hochladen

Erstellen Sie zum Containerisieren der Beispielanwendung in dem Verzeichnis, in dem sich die Quelldateien befinden, eine neue Datei namens Dockerfile und kopieren Sie den folgenden Inhalt in diese:

Go


# Use the offical golang image to create a binary.
# This is based on Debian and sets the GOPATH to /go.
# https://hub.docker.com/_/golang
FROM golang:1.15-buster as builder

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

# Retrieve application dependencies.
# This allows the container build to reuse cached dependencies.
# Expecting to copy go.mod and if present go.sum.
COPY go.* ./
RUN go mod download

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

# Build the binary.
RUN go build -mod=readonly -v -o server

# Use the official Debian slim image for a lean production container.
# https://hub.docker.com/_/debian
# https://docs.docker.com/develop/develop-images/multistage-build/#use-multi-stage-builds
FROM debian:buster-slim
RUN set -x && apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
    ca-certificates && \
    rm -rf /var/lib/apt/lists/*

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

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

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

# The .dockerignore file excludes files from the container build process.
#
# https://docs.docker.com/engine/reference/builder/#dockerignore-file

# Exclude locally vendored dependencies.
vendor/

# Exclude "build-time" ignore files.
.dockerignore
.gcloudignore

# Exclude git history and configuration.
.gitignore

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 copying both package.json AND package-lock.json (when available).
# Copying this first prevents re-running npm install on every code change.
COPY package*.json ./

# Install production dependencies.
# If you add a package-lock.json, speed your build by switching to 'npm ci'.
# RUN npm ci --only=production
RUN npm install --only=production

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

# Run the web service on container startup.
CMD [ "node", "index.js" ]

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

Dockerfile
.dockerignore
node_modules
npm-debug.log

Python

Das Python-Dockerfile startet einen Gunicorn-Webserver, der den von der Umgebungsvariable PORT definierten Port überwacht:


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

# Allow statements and log messages to immediately appear in the Knative logs
ENV PYTHONUNBUFFERED True

# 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 --timeout 0 main:app

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

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

Java


# Use the official maven/Java 8 image to create a build artifact.
# https://hub.docker.com/_/maven
FROM maven:3.6-jdk-11 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/openjdk11: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", "-jar", "/helloworld.jar"]

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

docs/serving/samples/hello-world/helloworld-csharp/Dockerfile

Dockerfile
.dockerignore
target/

C#

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/core/sdk:3.1-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.1-alpine AS runtime
WORKDIR /app
COPY --from=build /app/out ./

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

Wenn Sie Dateien aus lokalen dotnet-Build-Vorgängen vom Hochladen in Cloud Build ausschließen möchten, fügen Sie eine .gcloudignore-Datei im selben Verzeichnis hinzu, in dem sich die Quelldateien der Beispielanwendung befinden:

run/helloworld/.gcloudignore

# The .gcloudignore file excludes file from upload to Cloud Build.
# If this file is deleted, gcloud will default to .gitignore.
#
# https://cloud.google.com/cloud-build/docs/speeding-up-builds#gcloudignore
# https://cloud.google.com/sdk/gcloud/reference/topic/gcloudignore

**/obj/
**/bin/

# Exclude git history and configuration.
.git/
.gitignore

Wenn sich diese Zeilen in einer .gitignore-Datei befinden, können Sie diesen Schritt überspringen, da .gitignore eine Standardquelle für die .gcloudignore-Konfiguration ist.

Kopieren Sie diese Zeilen in eine .dockerignore-Datei für lokale Container-Builds mit der docker-Befehlszeile.

C++

Das C++-Dockerfile beginnt mit der Überwachung der Anwendung an dem Port, der mit der Umgebungsvariable PORT definiert wurde:

cloud-run-hello-world/Dockerfile

# We chose Alpine to build the image because it has good support for creating
# statically-linked, small programs.
ARG DISTRO_VERSION=edge
FROM alpine:${DISTRO_VERSION} AS base

# Create separate targets for each phase, this allows us to cache intermediate
# stages when using Google Cloud Build, and makes the final deployment stage
# small as it contains only what is needed.
FROM base AS devtools

# Install the typical development tools and some additions:
#   - ninja-build is a backend for CMake that often compiles faster than
#     CMake with GNU Make.
#   - Install the boost libraries.
RUN apk update && \
    apk add \
        boost-dev \
        boost-static \
        build-base \
        cmake \
        git \
        gcc \
        g++ \
        libc-dev \
        nghttp2-static \
        ninja \
        openssl-dev \
        openssl-libs-static \
        tar \
        zlib-static

# Copy the source code to /v/source and compile it.
FROM devtools AS build
COPY . /v/source
WORKDIR /v/source

# Run the CMake configuration step, setting the options to create
# a statically linked C++ program
RUN cmake -S/v/source -B/v/binary -GNinja \
    -DCMAKE_BUILD_TYPE=Release \
    -DBoost_USE_STATIC_LIBS=ON \
    -DCMAKE_EXE_LINKER_FLAGS=-static

# Compile the binary and strip it to reduce its size.
RUN cmake --build /v/binary
RUN strip /v/binary/cloud_run_hello

# Create the final deployment image, using `scratch` (the empty Docker image)
# as the starting point. Effectively we create an image that only contains
# our program.
FROM scratch AS cloud-run-hello
WORKDIR /r

# Copy the program from the previously created stage and make it the entry point.
COPY --from=build /v/binary/cloud_run_hello /r

ENTRYPOINT [ "/r/cloud_run_hello" ]

PHP

Das PHP-Dockerfile startet einen Apache-Webserver, der den von der Umgebungsvariablen PORT definierten Port überwacht:


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

# Configure PHP for Cloud Run.
# Precompile PHP code with opcache.
RUN docker-php-ext-install -j "$(nproc)" opcache
RUN set -ex; \
  { \
    echo "; Cloud Run enforces memory & timeouts"; \
    echo "memory_limit = -1"; \
    echo "max_execution_time = 0"; \
    echo "; File upload at Cloud Run network limit"; \
    echo "upload_max_filesize = 32M"; \
    echo "post_max_size = 32M"; \
    echo "; Configure Opcache for Containers"; \
    echo "opcache.enable = On"; \
    echo "opcache.validate_timestamps = Off"; \
    echo "; Configure Opcache Memory (Application-specific)"; \
    echo "opcache.memory_consumption = 32"; \
  } > "$PHP_INI_DIR/conf.d/cloud-run.ini"

# Copy in custom code from the host machine.
WORKDIR /var/www/html
COPY . ./

# Use the PORT environment variable in Apache configuration files.
# https://cloud.google.com/run/docs/reference/container-contract#port
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://github.com/docker-library/docs/blob/master/php/README.md#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

# The .dockerignore file excludes files from the container build process.
#
# https://docs.docker.com/engine/reference/builder/#dockerignore-file

# Exclude locally vendored dependencies.
vendor/

# Exclude "build-time" ignore files.
.dockerignore
.gcloudignore

# Exclude git history and configuration.
.gitignore

Ruby


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

# Install production dependencies.
WORKDIR /usr/src/app
COPY Gemfile Gemfile.lock ./
ENV BUNDLE_FROZEN=true
RUN gem install bundler && bundle install --without test

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

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

Fügen Sie die Datei .dockerignore hinzu, um Dateien aus Ihrem Container-Image auszuschließen.

Dockerfile
README.md
.ruby-version
.bundle/
vendor/

Shell

helloworld-shell/Dockerfile