クイックスタート: ビルドとデプロイ

このページでは、単純な Hello World アプリケーションを作成してコンテナイメージにパッケージ化し、コンテナイメージを Container Registry にアップロードしてから Cloud Run にデプロイする方法について説明します。ここでは、複数の言語でサンプルを示しますが、それ以外の言語を使用することもできます。

Qwiklabs のデモアカウントでもこのクイックスタートの手順に従うことができます。

始める前に

Google アカウントにログインします。
Google アカウントをまだお持ちでない場合は、新しいアカウントを登録します。

Cloud Console のプロジェクトセレクタページで、Cloud プロジェクトを選択または作成します。

注: この手順で作成するリソースをそのまま保持する予定でない場合、既存のプロジェクトを選択するのではなく、新しいプロジェクトを作成してください。チュートリアルの終了後にそのプロジェクトを削除すれば、プロジェクトに関連するすべてのリソースを削除できます。

プロジェクトセレクタのページに移動

Google Cloud プロジェクトに対して課金が有効になっていることを確認します。プロジェクトに対して課金が有効になっていることを確認する方法を学習する。

Cloud SDK をインストールして初期化します。

サンプルアプリケーションを作成する

Cloud Run で動作する Hello World サンプルアプリケーションを作成する手順については、ご使用の言語のタブをクリックしてください。

Go

helloworld-go という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-go
cd helloworld-go
```
go.mod ファイルを初期化して go モジュールを宣言します。

docs/serving/samples/hello-world/helloworld-go/go.mod
```
module github.com/knative/docs/docs/serving/samples/hello-world/helloworld-go

go 1.13
```

helloworld.go という名前で新しいファイルを作成し、次のコードを貼り付けます。

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("helloworld: received a request")
	target := os.Getenv("TARGET")
	if target == "" {
		target = "World"
	}
	fmt.Fprintf(w, "Hello %s!\n", target)
}

func main() {
	log.Print("helloworld: starting server...")

	http.HandleFunc("/", handler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("helloworld: listening on port %s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

このコードは、PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

Node.js

helloworld-nodejs という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-nodejs
cd helloworld-nodejs
```

package.json ファイルを作成し、次の内容を追加します。

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

同じディレクトリに index.js ファイルを作成し、次の行をコピーします。

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

このコードは、PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

Python

helloworld-python という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-python
cd helloworld-python
```
app.py という名前のファイルを作成し、次のコードを貼り付けます。

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)))
```
このコードは、「Hello World」という応答メッセージでリクエストに応答します。HTTP 処理は、コンテナ内の Gunicorn ウェブサーバーによって行われます。ローカルで使用するために直接呼び出された場合、このコードは PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

Java

Spring Boot アプリケーションを作成します。

コンソールから cURL コマンドと unzip コマンドを使用して、新しい空のウェブプロジェクトを作成します。

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

これで Spring Boot プロジェクトが作成されます。

/ マッピングを処理する @RestController と、TARGET 環境変数を指定する @Value フィールドを追加して、src/main/java/com/example/helloworld/HelloworldApplication.java の HelloworldApplication クラスを更新します。

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

このコードは、PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

他のフレームワークと一緒に Java を Cloud Run にデプロイする場合は、Spark と Vert.x の Knative サンプルを確認します。

C#

.NET Core SDK 3.1 をインストールします。これは、次のステップで新しいウェブプロジェクトを作成するためだけに行います。後述する Dockerfile により、すべての依存関係がコンテナに読み込まれます。
コンソールから dotnet コマンドを使用して、新しい空のウェブプロジェクトを作成します。
```
dotnet new web -o helloworld-csharp
```
helloworld-csharp ディレクトリに移動します。

Program.cs の CreateHostBuilder 定義を更新して、PORT 環境変数で定義されたポートをリッスンするようにします。

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

このコードは、PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。

Startup.cs という名前のファイルを作成し、次のコードを貼り付けます。

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

このコードは、「Hello World」という応答メッセージでリクエストに応答します。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

PHP

helloworld-php という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-php
cd helloworld-php
```
index.php という名前のファイルを作成し、次のコードを貼り付けます。

docs/serving/samples/hello-world/helloworld-php/index.php
```
<?php
$target = getenv('TARGET', true) ?: 'World';
echo sprintf("Hello %s!", $target);
```
このコードは、「Hello World」という応答メッセージでリクエストに応答します。HTTP 処理は、コンテナ内の Apache ウェブサーバーによって行われます。

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

Ruby

helloworld-ruby という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-ruby
cd helloworld-ruby
```
app.rb という名前のファイルを作成し、次のコードを貼り付けます。

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
```
このコードは、PORT 環境変数で定義されたポートをリッスンする基本的なウェブサーバーを作成します。
Gemfile という名前のファイルを作成し、次の内容をコピーします。

docs/serving/samples/hello-world/helloworld-ruby/Gemfile
```
source 'https://rubygems.org'

gem 'sinatra'
gem 'rack', '>= 2.0.6'
```
Bundler 2.0 以降がインストールされていない場合は、Bundler をインストールします。
次のコマンドを実行して Gemfile.lock ファイルを生成します。

bundle install

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

Shell

helloworld-shell という名前の新しいディレクトリを作成し、そのディレクトリに移動します。
```
mkdir helloworld-shell
cd helloworld-shell
```
script.sh ファイルを作成し、次の内容を追加します。

docs/serving/samples/hello-world/helloworld-shell/script.sh
```
#!/bin/sh
echo Hello ${TARGET:=World}!
```
このシェルスクリプトをすべての受信リクエストに実行するために、このサンプルでは小規模な Go プログラムを使用して基本ウェブサーバーを起動し、PORT 環境変数で定義されたポートをリッスンします。

invoke.go ファイルを作成し、次の内容を追加します。

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) {
	log.Print("helloworld: received a 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() {
	log.Print("helloworld: starting server...")

	http.HandleFunc("/", handler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	log.Printf("helloworld: listening on %s", port)
	log.Fatal(http.ListenAndServe(fmt.Sprintf(":%s", port), nil))
}

これでアプリは完成しました。このアプリをコンテナ化し、Container Registry にアップロードします。

その他

Cloud Run はほとんどの言語をサポートしています。この表にない言語のサンプルについては、以下をご覧ください。

ただし、Cloud Run ではこれらのサンプルを使用しないため、service.yaml と Docker Hub に関する資料はすべて無視してください。

アプリをコンテナ化して Container Registry にアップロードする

サンプルアプリをコンテナ化するには、ソースファイルと同じディレクトリに Dockerfile という名前の新しいファイルを作成し、次の内容をコピーします。

Go

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

# 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 using go modules.
# Allows container builds to reuse downloaded dependencies.
COPY go.* ./
RUN go mod download

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

# Build the binary.
# -mod=readonly ensures immutable go.mod and go.sum in container builds.
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

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

# 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" ]

.dockerignore ファイルを追加してコンテナイメージからファイルを除外します。

docs/serving/samples/hello-world/helloworld-nodejs/.dockerignore

Dockerfile
README.md
node_modules
npm-debug.log

Python

Python Dockerfile は、PORT 環境変数で定義されたポートをリッスンする Gunicorn ウェブサーバーを起動します。

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

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

.dockerignore ファイルを追加してコンテナイメージからファイルを除外します。

docs/serving/samples/hello-world/helloworld-python/.dockerignore

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

Java

docs/serving/samples/hello-world/helloworld-java-spring/Dockerfile

# 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", "-jar", "/helloworld.jar"]

C#

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

# 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"]

ローカルの dotnet ビルドオペレーションで生成されたファイルを Cloud Build へのアップロードから除外するには、サンプルアプリのソースファイルと同じディレクトリに .gcloudignore ファイルを追加します。

run/.gcloudignore

**/obj/
**/bin/

これらの行が .gitignore ファイルにある場合は、.gitignore が .gcloudignore 構成のデフォルトのソースであるため、この手順をスキップできます。

docker CLI を使用して、これらの行をローカルコンテナビルド用の .dockerignore ファイルにコピーします。

PHP

PHP Dockerfile は、PORT 環境変数で定義されたポートをリッスンする Apache ウェブサーバーを起動します。

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

# 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"

.dockerignore ファイルを追加してコンテナイメージからファイルを除外します。

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

Dockerfile
README.md
vendor

Ruby

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

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

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

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

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

Shell

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

# 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 using go modules.
# Allows container builds to reuse downloaded dependencies.
COPY go.* ./
RUN go mod download

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

# Build the binary.
# -mod=readonly ensures immutable go.mod and go.sum in container builds.
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
COPY script.sh ./

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

その他

Cloud Run はほとんどの言語をサポートしています。この表にない言語の Dockerfile のサンプルについては、以下をご覧ください。

ただし、Cloud Run では service.yaml と Docker Hub のサンプルを使用しないため、これらに関する資料は無視してください。

Dockerfile を含むディレクトリから次のコマンドを実行し、Cloud Build を使用してコンテナイメージをビルドします。

gcloud builds submit --tag gcr.io/PROJECT-ID/helloworld

PROJECT-ID は、GCP のプロジェクト ID です。gcloud config get-value project を実行すると取得できます。

成功すると、イメージ名（gcr.io/PROJECT-ID/helloworld）を含む SUCCESS メッセージが表示されます。イメージは Container Registry に保存され、必要に応じて再利用できます。

Cloud Run へのデプロイ

コンテナイメージをデプロイするには:

次のコマンドを使用してデプロイします。
```
gcloud run deploy --image gcr.io/PROJECT-ID/helloworld --platform managed
```
PROJECT-ID は、実際の GCP プロジェクト ID に置き換えてください。プロジェクト ID を表示するには、gcloud config get-value project コマンドを実行します。
1. サービス名の入力を求められます。Enter キーを押してデフォルト名の helloworld を受け入れます。
2. リージョンを指定するよう求められます。選択したリージョン（us-central1 など）を選択します。
3. 未認証の呼び出しを許可するように求められます。[y] と返信します。
デプロイが完了するまで少しお待ちください。成功すると、コマンドラインにサービス URL が表示されます。
ウェブブラウザでこのサービス URL を開き、デプロイしたコンテナにアクセスします。

Cloud Run のロケーション

Cloud Run はリージョナルです。つまり、Cloud Run サービスを実行するインフラストラクチャは特定のリージョンに配置され、そのリージョン内のすべてのゾーンで冗長的に利用できるように Google によって管理されます。

レイテンシ、可用性、耐久性の要件を満たしていることが、Cloud Run サービスを実行するリージョンを選択する際の主な判断材料になります。一般的には、ユーザーに最も近いリージョンを選択できますが、Cloud Run サービスで使用されている他の Google Cloud サービスのロケーションも考慮する必要があります。使用する Google Cloud サービスが複数のロケーションにまたがっていると、サービスの料金だけでなくレイテンシにも影響します。

Cloud Run は、次のリージョンで利用できます。

Tier 1 料金を適用

asia-east1（台湾）
asia-northeast1（東京）
asia-northeast2（大阪）
europe-north1（フィンランド）
europe-west1（ベルギー）
europe-west4（オランダ）
us-central1（アイオワ）
us-east1（サウスカロライナ）
us-east4（北バージニア）
us-west1（オレゴン）

Tier 2 料金を適用

australia-southeast1（シドニー）
northamerica-northeast1（モントリオール）

asia-northeast2、australia-southeast1、northamerica-northeast1 では、カスタムドメインを Cloud Run（フルマネージド）サービスにマッピングできません。

Cloud Run サービスをすでに作成している場合は、Cloud Console の Cloud Run ダッシュボードにリージョンを表示できます。

お疲れさまでした。コンテナイメージにパッケージ化されたアプリケーションが Cloud Run にデプロイされました。Cloud Run は、受信したリクエストを処理するためにコンテナイメージを自動的に水平方向にスケーリングします。リクエスト数が減少すると、インスタンス数が少なくなります。料金は、リクエストの処理中に使用した CPU、メモリ、ネットワークに対してのみ発生します。

クリーンアップ

テストプロジェクトの削除

サービスが使用されていない場合、Cloud Run の料金は発生しませんが、コンテナイメージを Container Registry に保存することで課金される場合があります。イメージを削除するか、Cloud プロジェクトを削除してこのような料金が発生しないようにできます。Cloud プロジェクトを削除すると、そのプロジェクト内で使用されているすべてのリソースに対する課金が停止します。

Cloud Console で [リソースの管理] ページに移動します。
[リソースの管理] ページに移動
プロジェクトリストで、削除するプロジェクトを選択し、[削除] をクリックします。
ダイアログでプロジェクト ID を入力し、[シャットダウン] をクリックしてプロジェクトを削除します。

次のステップ

コードソースからコンテナをビルドし、Container Registry に push する方法については、以下をご覧ください。

クイックスタート: ビルドとデプロイ

始める前に

サンプル アプリケーションを作成する

Go

Node.js

Python

Java

C#

PHP

Ruby

Shell

その他

アプリをコンテナ化して Container Registry にアップロードする

Go

Node.js

Python

Java

C#

PHP

Ruby

Shell

その他

Cloud Run へのデプロイ

Cloud Run のロケーション

Tier 1 料金を適用

Tier 2 料金を適用

クリーンアップ

テスト プロジェクトの削除

次のステップ

サンプルアプリケーションを作成する

テストプロジェクトの削除