Tutorial mengamankan layanan Cloud Run

Tutorial ini membahas cara membuat aplikasi dua layanan aman yang berjalan di Cloud Run. Aplikasi ini adalah editor Markdown mencakup layanan "frontend" publik yang dapat digunakan siapa pun untuk menulis teks markdown, dan layanan "backend" pribadi yang merender teks Markdown ke HTML.

Diagram yang menunjukkan alur permintaan dari 'editor' frontend ke 'renderer' backend. — Backend "Renderer" adalah layanan pribadi. Hal ini memungkinkan jaminan standar transformasi teks di seluruh organisasi tanpa melacak perubahan di seluruh library dalam berbagai bahasa.

Layanan backend bersifat pribadi menggunakan bawaan Cloud Run, fitur autentikasi layanan-ke-layanan berbasis IAM Cloud Run, yang membatasi siapa yang dapat memanggil layanan. Kedua layanan dibuat dengan prinsip hak istimewa terendah, tanpa akses ke Google Cloud lainnya kecuali jika diperlukan.

Batasan atau bukan sasaran dari tutorial ini

Tutorial ini tidak menunjukkan autentikasi pengguna akhir, yang menggunakan Identity Platform atau Firebase Authentication untuk membuat token ID pengguna dan memverifikasi identitas pengguna secara manual. Untuk mempelajari autentikasi pengguna akhir lebih lanjut, lihat tutorial Cloud Run untuk autentikasi pengguna akhir.
Tutorial ini tidak menunjukkan penggabungan metode autentikasi berbasis IAM dan token ID karena metode ini tidak didukung.

Tujuan

Buat akun layanan khusus dengan izin minimal untuk autentikasi layanan ke layanan dan akses layanan keseluruh Google Cloud.
Menulis, membangun, dan men-deploy dua layanan ke Cloud Run yang berinteraksi.
Buat permintaan antara layanan Cloud Run publik dan pribadi.

Biaya

Dalam dokumen ini, Anda menggunakan komponen Google Cloud yang dapat ditagih berikut:

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Di konsol Google Cloud, pada halaman pemilih project, pilih atau buat project Google Cloud.

Buka pemilih project

Pastikan penagihan telah diaktifkan untuk project Google Cloud Anda.

Aktifkan API Cloud Run.
Mengaktifkan API

Instal dan lakukan inisialisasi gcloud CLI.
Instal curl untuk mencoba layanan

Peran yang diperlukan

Untuk mendapatkan izin yang Anda perlukan untuk menyelesaikan tutorial, minta administrator Anda untuk memberi Anda peran IAM berikut di project Anda:

Editor Cloud Build (roles/cloudbuild.builds.editor)
Admin Cloud Run (roles/run.admin)
Membuat Akun Layanan (roles/iam.serviceAccountCreator)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Service Account User (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) [Konsumen Penggunaan Layanan]
Admin Penyimpanan (roles/storage.admin)

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Menyiapkan default gcloud

Untuk mengonfigurasi gcloud dengan setelan default untuk layanan Cloud Run Anda:

Setel project default Anda:
```
gcloud config set project PROJECT_ID
```
Ganti PROJECT_ID dengan nama project yang Anda buat untuk tutorial ini.
Konfigurasi gcloud untuk region yang Anda pilih:
```
gcloud config set run/region REGION
```
Ganti REGION dengan region Cloud Run pilihan Anda yang didukung.

Lokasi Cloud Run

Cloud Run bersifat regional, berarti infrastruktur yang menjalankan layanan Cloud Run Anda terletak di region tertentu dan dikelola oleh Google agar tersedia secara redundan di semua zona dalam region tersebut.

Memenuhi persyaratan latensi, ketersediaan, atau ketahanan adalah faktor utama untuk memilih region tempat layanan Cloud Run dijalankan. Pada umumnya, Anda dapat memilih region yang paling dekat dengan pengguna Anda, tetapi Anda harus mempertimbangkan lokasi dari produk Google Cloud lain yang digunakan oleh layanan Cloud Run Anda. Menggunakan produk Google Cloud secara bersamaan di beberapa lokasi dapat memengaruhi latensi serta biaya layanan Anda.

Cloud Run tersedia di region berikut:

Tergantung harga Tingkat 1

asia-east1 (Taiwan)
asia-northeast1 (Tokyo)
asia-northeast2 (Osaka)
europe-north1 (Finlandia) CO₂ Rendah
europe-southwest1 (Madrid)
europe-west1 (Belgia) CO₂ Rendah
europe-west4 (Belanda)
europe-west8 (Milan)
europe-west9 (Paris) CO₂ Rendah
me-west1 (Tel Aviv)
us-central1 (Iowa) CO₂ rendah
us-east1 (South Carolina)
us-east4 (North Virginia)
us-east5 (Columbus)
us-south1 (Dallas)
us-west1 (Oregon) CO₂ Rendah

Tergantung harga Tingkat 2

africa-south1 (Johannesburg)
asia-east2 (Hong Kong)
asia-northeast3 (Seoul, Korea Selatan)
asia-southeast1 (Singapura)
asia-southeast2 (Jakarta)
asia-south1 (Mumbai, India)
asia-south2 (Delhi, India)
australia-southeast1 (Sydney)
australia-southeast2 (Melbourne)
europe-central2 (Warsawa, Polandia)
europe-west10 (Berlin)
europe-west12 (Turin)
europe-west2 (London, Inggris Raya) CO₂ Rendah
europe-west3 (Frankfurt, Jerman) CO₂ Rendah
europe-west6 (Zurich, Swiss) CO₂ Rendah
me-central1 (Doha)
me-central2 (Damam)
northamerica-northeast1 (Montreal) CO₂ Rendah
northamerica-northeast2 (Toronto) CO₂ Rendah
southamerica-east1 (Sao Paulo, Brasil) CO₂ Rendah
southamerica-west1 (Santiago, Cile) CO₂ Rendah
us-west2 (Los Angeles)
us-west3 (Salt Lake City)
us-west4 (Las Vegas)

Jika sudah membuat layanan Cloud Run, Anda dapat melihat region di dasbor Cloud Run di Konsol Google Cloud.

Mengambil contoh kode

Untuk mengambil contoh kode agar dapat digunakan:

Clone repositori aplikasi contoh tersebut ke Cloud Shel atau mesin lokal Anda:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.
C#
```
git clone https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
```
Atau, Anda dapat mendownload sampel sebagai file ZIP dan mengekstraknya.

Ubah ke direktori yang memuat kode contoh Cloud Run:

Node.js

cd nodejs-docs-samples/run/markdown-preview/

Python

cd python-docs-samples/run/markdown-preview/

Go

cd golang-samples/run/markdown-preview/

Java

cd java-docs-samples/run/markdown-preview/

C#

cd dotnet-docs-samples/run/markdown-preview/

Meninjau layanan rendering Markdown pribadi

Dari perspektif frontend, ada spesifikasi API sederhana untuk layanan Markdown:

Satu endpoint di /
Mengharapkan permintaan POST
Isi permintaan POST adalah teks Markdown

Anda mungkin ingin meninjau semua kode untuk menemukan masalah keamanan atau hanya mempelajarinya lebih lanjut dengan menjelajahi ./renderer/direktori Perhatikan bahwa tutorial tidak menjelaskan kode transformasi Markdown.

Mengirimkan layanan rendering Markdown pribadi

Untuk mengirimkan kode Anda, bangun dengan Cloud Build, upload ke Container Registry, dan deploy ke Cloud Run:

Ubah ke direktori renderer:

Node.js

cd renderer/

Python

cd renderer/

Go

cd renderer/

Java

cd renderer/

C#

cd Samples.Run.MarkdownPreview.Renderer/

Jalankan perintah tersebut untuk mem-build container dan publikasikan di Container Registry.
Node.js
```
gcloud builds submit --tag gcr.io/PROJECT_ID/renderer
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan renderer merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Python
```
gcloud builds submit --tag gcr.io/PROJECT_ID/renderer
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan renderer merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Go
```
gcloud builds submit --tag gcr.io/PROJECT_ID/renderer
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan renderer merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Java

Contoh ini menggunakan Jib untuk mem-build image Docker menggunakan alat Java umum. Jib mengoptimalkan build container tanpa memerlukan Dockerfile atau menginstal Docker. Pelajari lebih lanjut cara mem-build container Java dengan Jib.
1. Gunakan bantuan kredensial gcloud untuk memberi otorisasi Docker agar dikirim ke Container Registry Anda.
```
gcloud auth configure-docker
```
2. Gunakan Plugin Maven Jib untuk mem-build dan mengirim container ke Container Registry.
```
mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/renderer
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda dan renderer merupakan nama yang ingin Anda berikan pada layanan Anda.

Setelah berhasil, Anda akan melihat pesan BUILD SUCCESS. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
C#
```
gcloud builds submit --tag gcr.io/PROJECT_ID/renderer
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda dan renderer merupakan nama yang ingin Anda berikan pada layanan Anda.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Deploy sebagai layanan pribadi dengan akses terbatas.

Cloud Run menyediakan fitur kontrol akses dan layanan identitas siap pakai. Kontrol akses menyediakan lapisan autentikasi yang membatasi pengguna dan layanan lainnya agar tidak memanggil layanan. Identitas layanan memungkinkan pembatasan layanan Anda agar tidak mengakses resource Google Cloud lainnya dengan membuat akun layanan khusus dengan izin terbatas.
1. Buat akun layanan untuk digunakan sebagai "identitas compute" dari layanan render. Secara default, opsi ini tidak memiliki hak istimewa selain keanggotaan project.
  Command line
```
gcloud iam service-accounts create renderer-identity
```
  Terraform
  
  Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.
  resource "google_service_account" "renderer" { provider = google-beta account_id = "renderer-identity" display_name = "Service identity of the Renderer (Backend) service." }
  Markdown layanan rendering tidak terintegrasi langsung dengan hal lainnya di Google Cloud. Aplikasi ini tidak memerlukan izin lebih lanjut.
2. Deploy dengan renderer-identity akun layanan dan tolak akses yang tidak diautentikasi.
  Command line
```
gcloud run deploy renderer \
--image gcr.io/PROJECT_ID/renderer \
--service-account renderer-identity \
--no-allow-unauthenticated
```
  Cloud Run dapat menggunakan nama akun layanan dalam format pendek bukan alamat email lengkap jika akun layanan merupakan bagian dari project yang sama.
  Terraform
  
  Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.
  resource "google_cloud_run_v2_service" "renderer" { provider = google-beta name = "renderer" location = "us-central1" template { containers { # Replace with the URL of your Secure Services > Renderer image. # gcr.io/<PROJECT_ID>/renderer image = "us-docker.pkg.dev/cloudrun/container/hello" } service_account = google_service_account.renderer.email } }

Mencoba layanan rendering Markdown pribadi

Layanan pribadi tidak dapat dimuat langsung oleh browser web. Sebagai gantinya, gunakan curl atau alat CLI permintaan HTTP yang memungkinkan injeksi Authorization header.

Untuk mengirim beberapa teks tebal ke layanan dan melihatnya mengubah markdown asterisks menjadi tag <strong> HTML:

Mendapatkan URL dari output deployment.
Gunakan gcloud untuk mendapatkan token identitas khusus pengembangan hanya untuk autentikasi:
```
TOKEN=$(gcloud auth print-identity-token)
```

Buat permintaan curl yang meneruskan teks Markdown mentah sebagai parameter string kueri yang akan menjadi URL:

curl -H "Authorization: Bearer $TOKEN" \
   -H 'Content-Type: text/plain' \
   -d '**Hello Bold Text**' \
   SERVICE_URL

Responsnya harus berupa cuplikan HTML:
```
 <strong>Hello Bold Text</strong>
```

Meninjau integrasi antara layanan editor dan rendering

Layanan editor menyediakan UI entri teks yang sederhana dan ruang untuk melihat pratinjau HTML. Sebelum melanjutkan, tinjau kode yang diambil sebelumnya dengan membuka direktori ./editor/.

Selanjutnya, pelajari beberapa bagian kode berikut yang mengintegrasikan kedua layanan tersebut dengan aman.

Node.js

Modul render.js membuat permintaan terautentikasi ke layanan renderer pribadi. Ini menggunakan layanan etaata Google Cloud pada lingkungan Cloud Run untuk membuat token identitas dan menambahkannya pada permintaan HTTP sebagai bagian dari Authorization header.

Di lingkungan lain, render.js menggunakan Kredensial Default Aplikasi untuk meminta token dari server Google.

const {GoogleAuth} = require('google-auth-library');
const got = require('got');
const auth = new GoogleAuth();

let client, serviceUrl;

// renderRequest creates a new HTTP request with IAM ID Token credential.
// This token is automatically handled by private Cloud Run (fully managed) and Cloud Functions.
const renderRequest = async markdown => {
  if (!process.env.EDITOR_UPSTREAM_RENDER_URL)
    throw Error('EDITOR_UPSTREAM_RENDER_URL needs to be set.');
  serviceUrl = process.env.EDITOR_UPSTREAM_RENDER_URL;

  // Build the request to the Renderer receiving service.
  const serviceRequestOptions = {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    body: markdown,
    timeout: 3000,
  };

  try {
    // Create a Google Auth client with the Renderer service url as the target audience.
    if (!client) client = await auth.getIdTokenClient(serviceUrl);
    // Fetch the client request headers and add them to the service request headers.
    // The client request headers include an ID token that authenticates the request.
    const clientHeaders = await client.getRequestHeaders();
    serviceRequestOptions.headers['Authorization'] =
      clientHeaders['Authorization'];
  } catch (err) {
    throw Error('could not create an identity token: ' + err.message);
  }

  try {
    // serviceResponse converts the Markdown plaintext to HTML.
    const serviceResponse = await got(serviceUrl, serviceRequestOptions);
    return serviceResponse.body;
  } catch (err) {
    throw Error('request to rendering service failed: ' + err.message);
  }
};

Mengurai markdown dari JSON dan mengirimkannya ke layanan Renderer untuk diubah menjadi HTML.

app.post('/render', async (req, res) => {
  try {
    const markdown = req.body.data;
    const response = await renderRequest(markdown);
    res.status(200).send(response);
  } catch (err) {
    console.error('Error rendering markdown:', err);
    res.status(500).send(err);
  }
});

Python

Metode new_request membuat permintaan yang diautentikasi ke layanan pribadi. ID ini menggunakan server metadata Google Cloud di lingkungan Cloud Run untuk membuat token identitas dan menambahkannya ke permintaan HTTP sebagai bagian dari Authorization header.

Di lingkungan lain, new_request permintaan token identitas dari server google menggunakan autentikasi dengan Kredensial Default Aplikasi.

import os
import urllib

import google.auth.transport.requests
import google.oauth2.id_token

def new_request(data):
    """Creates a new HTTP request with IAM ID Token credential.

    This token is automatically handled by private Cloud Run and Cloud Functions.

    Args:
        data: data for the authenticated request

    Returns:
        The response from the HTTP request
    """
    url = os.environ.get("EDITOR_UPSTREAM_RENDER_URL")
    if not url:
        raise Exception("EDITOR_UPSTREAM_RENDER_URL missing")

    req = urllib.request.Request(url, data=data.encode())
    auth_req = google.auth.transport.requests.Request()
    target_audience = url

    id_token = google.oauth2.id_token.fetch_id_token(auth_req, target_audience)
    req.add_header("Authorization", f"Bearer {id_token}")

    response = urllib.request.urlopen(req)
    return response.read()

Mengurai markdown dari JSON dan mengirimkannya ke layanan Renderer untuk diubah menjadi HTML.

@app.route("/render", methods=["POST"])
def render_handler():
    """Parse the markdown from JSON and send it to the Renderer service to be
    transformed into HTML.
    """
    body = request.get_json(silent=True)
    if not body:
        return "Error rendering markdown: Invalid JSON", 400

    data = body["data"]
    try:
        parsed_markdown = render.new_request(data)
        return parsed_markdown, 200
    except Exception as err:
        return f"Error rendering markdown: {err}", 500

Go

RenderService membuat permintaan yang diautentikasi ke layanan pribadi. ID ini menggunakan server metadata Google Cloud di lingkungan Cloud Run untuk membuat token identitas dan menambahkannya ke permintaan HTTP sebagai bagian dari Authorization header.

Di lingkungan lain, RenderService permintaan token identitas dari server google menggunakan autentikasi dengan Kredensial Default Aplikasi.

import (
	"bytes"
	"context"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"

	"golang.org/x/oauth2"
	"google.golang.org/api/idtoken"
)

// RenderService represents our upstream render service.
type RenderService struct {
	// URL is the render service address.
	URL string
	// tokenSource provides an identity token for requests to the Render Service.
	tokenSource oauth2.TokenSource
}

// NewRequest creates a new HTTP request to the Render service.
// If authentication is enabled, an Identity Token is created and added.
func (s *RenderService) NewRequest(method string) (*http.Request, error) {
	req, err := http.NewRequest(method, s.URL, nil)
	if err != nil {
		return nil, fmt.Errorf("http.NewRequest: %w", err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	// Create a TokenSource if none exists.
	if s.tokenSource == nil {
		s.tokenSource, err = idtoken.NewTokenSource(ctx, s.URL)
		if err != nil {
			return nil, fmt.Errorf("idtoken.NewTokenSource: %w", err)
		}
	}

	// Retrieve an identity token. Will reuse tokens until refresh needed.
	token, err := s.tokenSource.Token()
	if err != nil {
		return nil, fmt.Errorf("TokenSource.Token: %w", err)
	}
	token.SetAuthHeader(req)

	return req, nil
}

Permintaan dikirim ke Layanan Renderer setelah menambahkan teks markdown untuk ditransformasikan ke dalam HTML. Kesalahan respons ditangani untuk membedakan masalah komunikasi dari fungsi rendering.


var renderClient = &http.Client{Timeout: 30 * time.Second}

// Render converts the Markdown plaintext to HTML.
func (s *RenderService) Render(in []byte) ([]byte, error) {
	req, err := s.NewRequest(http.MethodPost)
	if err != nil {
		return nil, fmt.Errorf("RenderService.NewRequest: %w", err)
	}
	req.Body = ioutil.NopCloser(bytes.NewReader(in))
	defer req.Body.Close()

	resp, err := renderClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("http.Client.Do: %w", err)
	}

	out, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("ioutil.ReadAll: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return out, fmt.Errorf("http.Client.Do: %s (%d): request not OK", http.StatusText(resp.StatusCode), resp.StatusCode)
	}

	return out, nil
}

Java

makeAuthenticatedRequest membuat permintaan yang diautentikasi ke layanan pribadi. Ini menggunakan layanan metadata Google Cloud pada lingkungan Cloud Run untuk membuat token identitas dan menambahkannya pada permintaan HTTP sebagai bagian dari Authorization header.

Di lingkungan lain, makeAuthenticatedRequest permintaan token identitas dari server google menggunakan autentikasi dengan Kredensial Default Aplikasi.

// makeAuthenticatedRequest creates a new HTTP request authenticated by a JSON Web Tokens (JWT)
// retrievd from Application Default Credentials.
public String makeAuthenticatedRequest(String url, String markdown) {
  String html = "";
  try {
    // Retrieve Application Default Credentials
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    IdTokenCredentials tokenCredentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) credentials)
            .setTargetAudience(url)
            .build();

    // Create an ID token
    String token = tokenCredentials.refreshAccessToken().getTokenValue();
    // Instantiate HTTP request
    MediaType contentType = MediaType.get("text/plain; charset=utf-8");
    okhttp3.RequestBody body = okhttp3.RequestBody.create(markdown, contentType);
    Request request =
        new Request.Builder()
            .url(url)
            .addHeader("Authorization", "Bearer " + token)
            .post(body)
            .build();

    Response response = ok.newCall(request).execute();
    html = response.body().string();
  } catch (IOException e) {
    logger.error("Unable to get rendered data", e);
  }
  return html;
}

Mengurai markdown dari JSON dan mengirimkannya ke layanan Renderer untuk diubah menjadi HTML.

// '/render' expects a JSON body payload with a 'data' property holding plain text
// for rendering.
@PostMapping(value = "/render", consumes = "application/json")
public String render(@RequestBody Data data) {
  String markdown = data.getData();

  String url = System.getenv("EDITOR_UPSTREAM_RENDER_URL");
  if (url == null) {
    String msg =
        "No configuration for upstream render service: "
            + "add EDITOR_UPSTREAM_RENDER_URL environment variable";
    logger.error(msg);
    throw new IllegalStateException(msg);
  }

  String html = makeAuthenticatedRequest(url, markdown);
  return html;
}

C#

GetAuthenticatedPostResponse membuat permintaan yang diautentikasi ke layanan pribadi. Ini menggunakan layanan metadata Google Cloud pada lingkungan Cloud Run untuk membuat token identitas dan menambahkannya pada permintaan HTTP sebagai bagian dari Authorization header.

Di lingkungan lain, GetAuthenticatedPostResponse permintaan token identitas dari server google menggunakan autentikasi dengan Kredensial Default Aplikasi.

private async Task<string> GetAuthenticatedPostResponse(string url, string postBody)
{
    // Get the OIDC access token from the service account via Application Default Credentials
    GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync();
    OidcToken token = await credential.GetOidcTokenAsync(OidcTokenOptions.FromTargetAudience(url));
    string accessToken = await token.GetAccessTokenAsync();

    // Create request to the upstream service with the generated OAuth access token in the Authorization header
    var upstreamRequest = new HttpRequestMessage(HttpMethod.Post, url);
    upstreamRequest.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
    upstreamRequest.Content = new StringContent(postBody);

    var upstreamResponse = await _httpClient.SendAsync(upstreamRequest);
    upstreamResponse.EnsureSuccessStatusCode();

    return await upstreamResponse.Content.ReadAsStringAsync();
}

Mengurai markdown dari JSON dan mengirimkannya ke layanan Renderer untuk diubah menjadi HTML.

public async Task<IActionResult> Index([FromBody] RenderModel model)
{
    var markdown = model.Data ?? string.Empty;
    var renderedHtml = await GetAuthenticatedPostResponse(_editorUpstreamRenderUrl, markdown);
    return Content(renderedHtml);
}

Mengirim layanan editor publik

Untuk mem-build dan men-deploy kode Anda:

Ubah ke direktori editor:

Node.js

cd ../editor

Python

cd ../editor

Go

cd ../editor

Java

cd ../editor

C#

cd ../Samples.Run.MarkdownPreview.Editor/

Jalankan perintah tersebut untuk mem-build container dan publikasikan di Container Registry.
Node.js
```
gcloud builds submit --tag gcr.io/PROJECT_ID/editor
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan editor merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Python
```
gcloud builds submit --tag gcr.io/PROJECT_ID/editor
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan editor merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Go
```
gcloud builds submit --tag gcr.io/PROJECT_ID/editor
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda, dan editor merupakan nama yang ingin Anda berikan ke layanan.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
Java
Contoh ini menggunakan Jib untuk mem-build image Docker menggunakan alat Java umum. Jib mengoptimalkan build container tanpa memerlukan Dockerfile atau menginstal Docker. Pelajari lebih lanjut cara mem-build container Java dengan Jib.
```
mvn compile jib:build -Dimage=gcr.io/PROJECT_ID/editor
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda dan editor merupakan nama yang ingin Anda berikan pada layanan Anda.

Setelah berhasil, Anda akan melihat pesan BUILD SUCCESS. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.
C#
```
gcloud builds submit --tag gcr.io/PROJECT_ID/editor
```
Dengan PROJECT_ID sebagai project ID Google Cloud Anda dan editor merupakan nama yang ingin Anda berikan pada layanan Anda.

Setelah berhasil, Anda akan melihat pesan SUCCESS yang berisi ID, waktu pembuatan, dan nama image. Image tersebut disimpan di Container Registry dan dapat digunakan kembali bila diinginkan.

Deploy sebagai layanan pribadi dengan akses khusus ke layanan rendering.

Buat akun layanan untuk digunakan sebagai "identitas compute" dari layanan render. Secara default, opsi ini tidak memiliki hak istimewa selain keanggotaan project.
Command line
```
gcloud iam service-accounts create editor-identity
```
Terraform

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.
```
resource "google_service_account" "editor" {
  provider     = google-beta
  account_id   = "editor-identity"
  display_name = "Service identity of the Editor (Frontend) service."
}
```
Layanan Editor tidak perlu berinteraksi dengan hal lain di Google Cloud selain layanan rendering Markdown.
Memberikan akses ke identitas komputasi editor-identity untuk memanggil layanan rendering Markdown. Setiap layanan yang menggunakan identitas ini sebagai identitas komputasi akan memiliki hak istimewa ini.
Command line
```
gcloud run services add-iam-policy-binding renderer \
--member serviceAccount:editor-identity@PROJECT_ID.iam.gserviceaccount.com \
--role roles/run.invoker
```
Terraform

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.
```
resource "google_cloud_run_service_iam_member" "editor_invokes_renderer" {
  provider = google-beta
  location = google_cloud_run_v2_service.renderer.location
  service  = google_cloud_run_v2_service.renderer.name
  role     = "roles/run.invoker"
  member   = "serviceAccount:${google_service_account.editor.email}"
}
```
Karena ini diberi perab invoker dalam konteks layanan render, layanan render adalah satu-satunya layanan Cloud Run pribadi yang dapat dipanggil editor.

Deploy dengan akun layanan editor-identity dan izinkan akses publik yang tidak diautentikasi.

Command line

gcloud run deploy editor --image gcr.io/PROJECT_ID/editor \
--service-account editor-identity \
--set-env-vars EDITOR_UPSTREAM_RENDER_URL=RENDERER_SERVICE_URL \
--allow-unauthenticated

Ganti,

PROJECT_ID dengan project ID Anda
RENDERER_SERVICE_URL dengan URL yang diberikan setelah men-deploy layanan rendering Markdown.

Terraform

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

Deploy layanan editor:

resource "google_cloud_run_v2_service" "editor" {
  provider = google-beta
  name     = "editor"
  location = "us-central1"
  template {
    containers {
      # Replace with the URL of your Secure Services > Editor image.
      #   gcr.io/<PROJECT_ID>/editor
      image = "us-docker.pkg.dev/cloudrun/container/hello"
      env {
        name  = "EDITOR_UPSTREAM_RENDER_URL"
        value = google_cloud_run_v2_service.renderer.uri
      }
    }
    service_account = google_service_account.editor.email

  }
}

Memberikan allUsers izin untuk memanggil layanan:

data "google_iam_policy" "noauth" {
  provider = google-beta
  binding {
    role = "roles/run.invoker"
    members = [
      "allUsers",
    ]
  }
}

resource "google_cloud_run_service_iam_policy" "noauth" {
  provider = google-beta
  location = google_cloud_run_v2_service.editor.location
  project  = google_cloud_run_v2_service.editor.project
  service  = google_cloud_run_v2_service.editor.name

  policy_data = data.google_iam_policy.noauth.policy_data
}

Memahami traffic HTTPS

Ada tiga permintaan HTTP yang terlibat dalam rendering markdown menggunakan layanna ini.

Diagram yang menunjukkan alur permintaan dari pengguna ke editor, editor untuk mendapatkan token dari server Metadata, editor untuk membuat permintaan ke layanan render, layanan render untuk menampilkan HTML ke editor. — Layanan frontend dengan `editor-identity` memanggil layanan render. Dan `editor-identity` keduanya `renderer-identity` memiliki izin terbatas sehingga eksploitasi atau injeksi keamanan pun memiliki batas akses ke resource Google Cloud lainnya.

Melakukan Percobaan

Untuk mencoba aplikasi dua layanan yang selesai:

Buka browser Anda ke URL yang disediakan pada langkah deployment di atas.
Cobalah edit teks Markdown di sebelah kiri lalu klik tombol untuk melihat pratinjaunya di sebelah kanan.

Kodenya akan terlihat seperti berikut:

Jika Anda memilih untuk terus mengembangkan layanan ini, perlu diingat bahwa layanan tersebut telah membatasi akses Identity and Access Management (IAM) ke bagian lain Google Cloud dan perlu diberi peran IAM tambahan untuk mengakses banyak layanan lainnya.

Pembersihan

Jika Anda membuat project baru untuk tutorial ini, hapus project tersebut. Jika Anda menggunakan project yang ada dan ingin mempertahankannya tanpa ada perubahan yang ditambahkan dalam tutorial ini, hapus resource yang dibuat untuk tutorial.

Menghapus project

Cara termudah untuk menghilangkan penagihan adalah dengan menghapus project yang Anda buat untuk tutorial.

Untuk menghapus project:

Perhatian: Menghapus project memiliki efek berikut:

Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Menghapus resource tutorial

Hapus layanan Cloud Run yang telah Anda deploy dalam tutorial ini:
Command line
```
gcloud run services delete editor
gcloud run services delete renderer
```
Anda juga dapat menghapus layanan Cloud Run dari Konsol Google Cloud.
Hapus konfigurasi default gcloud yang Anda tambahkan selama penyiapan tutorial.
```
 gcloud config unset run/region
```
Hapus konfigurasi project:
```
 gcloud config unset project
```
Hapus resource Google Cloud lain yang dibuat dalam tutorial ini:
- Hapus image container editor yang dinobatkan gcr.io/PROJECT_ID/editor dari Container Registry
- Hapus image container render yang dinobatkan gcr.io/PROJECT_ID/renderer dari Container Registry
- Hapus akun layanan editor editor-identity@PROJECT_ID.iam.gserviceaccount.com
- Hapus akun layanan render renderer-identity@PROJECT_ID.iam.gserviceaccount.com

Langkah selanjutnya

Buat project Anda lebih aman dengan mengikuti checklist menggunakan IAM dengan aman
Perluas aplikasi contoh ini untuk melacak penggunaan Markdown dengan metrik kustom Cloud Monitoring
Tinjau tutorial Pub/Sub untuk mengetahui pendekatan yang aman terhadap microservice asinkron