Autentikasi antarlayanan

Selain mengautentikasi permintaan pengguna akhir, Anda mungkin ingin mengautentikasi layanan (pengguna non-manusia) yang membuat permintaan ke API Anda. Halaman ini menjelaskan cara menggunakan akun layanan untuk memberikan autentikasi bagi manusia atau layanan.

Ringkasan

Untuk mengidentifikasi layanan yang mengirim permintaan ke API, Anda menggunakan akun layanan. Layanan panggilan menggunakan kunci pribadi akun layanan untuk menandatangani Token Web JSON (JWT) yang aman dan mengirimkan JWT yang ditandatangani dalam permintaan ke API Anda.

Untuk menerapkan autentikasi akun layanan di API dan layanan panggilan Anda:

  1. Buat akun layanan dan kunci untuk digunakan oleh layanan panggilan.
  2. Tambahkan dukungan untuk autentikasi di konfigurasi API untuk layanan API Gateway Anda.

  3. Tambahkan kode ke layanan panggilan yang:

    • Membuat JWT dan menandatanganinya dengan kunci pribadi akun layanan.
    • Mengirim JWT yang ditandatangani dalam permintaan ke API.

API Gateway memvalidasi bahwa klaim dalam JWT cocok dengan konfigurasi dalam konfigurasi API Anda sebelum meneruskan permintaan ke API Anda. API Gateway tidak memeriksa izin Cloud Identity yang telah Anda berikan di akun layanan.

Prasyarat

Halaman ini mengasumsikan bahwa Anda telah:

Membuat akun layanan dengan kunci

Anda memerlukan akun layanan dengan file kunci pribadi yang digunakan layanan panggilan untuk menandatangani JWT. Jika memiliki lebih dari satu layanan yang mengirim permintaan ke API, Anda dapat membuat satu akun layanan untuk mewakili semua layanan panggilan. Jika Anda perlu membedakan antara layanan—misalnya, layanan tersebut mungkin memiliki izin yang berbeda—Anda dapat membuat akun layanan dan kunci untuk setiap layanan panggilan.

Bagian ini menunjukkan cara menggunakan konsol Google Cloud dan alat command line gcloud untuk membuat akun layanan dan file kunci pribadi serta untuk menetapkan peran Service Account Token Creator untuk akun layanan tersebut. Untuk informasi tentang cara menggunakan API untuk melakukan tugas ini, lihat Membuat dan mengelola akun layanan.

Untuk membuat akun layanan dengan kunci:

Konsol Google Cloud

Buat akun layanan:

  1. Di konsol Google Cloud, buka Create service account.

    Buka Create service account

  2. Pilih project.

  3. Di kolom Nama akun layanan, masukkan nama. Konsol Google Cloud akan mengisi kolom ID akun layanan berdasarkan nama ini.

  4. Opsional: Di kolom Deskripsi akun layanan, masukkan deskripsi.

  5. Klik Create.

  6. Klik kolom Pilih peran.

    Di bagian Semua peran, pilih Akun Layanan > Pembuat Token Akun Layanan.

  7. Klik Lanjutkan.

  8. Klik Selesai untuk menyelesaikan pembuatan akun layanan.

    Jangan tutup jendela browser Anda. Anda akan menggunakan halaman tersebut pada prosedur berikutnya.

Membuat kunci akun layanan:

  1. Di konsol Google Cloud, klik alamat email untuk akun layanan yang telah dibuat.
  2. Klik Kunci.
  3. Klik Tambahkan kunci, lalu Buat kunci baru.
  4. Klik Buat. File kunci JSON akan didownload ke komputer Anda.
  5. Klik Close.

gcloud

Anda dapat menjalankan perintah berikut menggunakan Google Cloud CLI di komputer lokal, atau dalam Cloud Shell.

  1. Tetapkan akun default untuk gcloud. Jika Anda memiliki lebih dari satu akun, pastikan untuk memilih akun yang ada dalam project Google Cloud yang ingin Anda gunakan.

    gcloud auth login

  2. Menampilkan project ID untuk project Google Cloud Anda.

    gcloud projects list

  3. Tetapkan project default. Ganti PROJECT_ID dengan project ID Google Cloud yang ingin Anda gunakan.

    gcloud config set project PROJECT_ID

  4. Membuat akun layanan. Ganti SA_NAME dan SA_DISPLAY_NAME dengan nama dan nama tampilan yang ingin Anda gunakan.

    gcloud iam service-accounts create SA_NAME \
  --display-name "SA_DISPLAY_NAME"

  5. Menampilkan alamat email untuk akun layanan yang baru saja Anda buat.

    gcloud iam service-accounts list

  6. Tambahkan peran Service Account Token Creator. Ganti SA_EMAIL_ADDRESS dengan alamat email akun layanan.

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member serviceAccount:SA_EMAIL_ADDRESS \
  --role roles/iam.serviceAccountTokenCreator

  7. Buat file kunci akun layanan di direktori kerja saat ini. Ganti FILE_NAME dengan nama yang ingin Anda gunakan untuk file kunci. Secara default, perintah gcloud akan membuat file JSON.

    gcloud iam service-accounts keys create FILE_NAME.json \
  --iam-account SA_EMAIL_ADDRESS

Lihat referensi gcloud untuk mengetahui informasi selengkapnya tentang perintah sebelumnya.

Untuk informasi tentang cara mengamankan kunci pribadi, lihat Praktik terbaik untuk mengelola kredensial.

Mengonfigurasi API untuk mendukung autentikasi

Saat membuat konfigurasi API untuk gateway, Anda menentukan akun layanan yang digunakan gateway untuk berinteraksi dengan layanan lain. Untuk mengaktifkan autentikasi akun layanan bagi layanan yang memanggil gateway Anda, ubah objek persyaratan keamanan dan objek definisi keamanan di konfigurasi API Anda. Dengan mengikuti langkah-langkah di bawah, API Gateway akan dapat memvalidasi klaim dalam JWT yang ditandatangani yang digunakan oleh layanan panggilan.

  1. Tambahkan akun layanan sebagai penerbit di konfigurasi API Anda.

    securityDefinitions:
  DEFINITION_NAME:
    authorizationUrl: ""
    flow: "implicit"
    type: "oauth2"
    x-google-issuer: "SA_EMAIL_ADDRESS"
    x-google-jwks_uri: "https://www.googleapis.com/robot/v1/metadata/x509/SA_EMAIL_ADDRESS"
    • Ganti DEFINITION_NAME dengan string yang mengidentifikasi definisi keamanan ini. Anda dapat menggantinya dengan nama akun layanan atau nama yang mengidentifikasi layanan panggilan.
    • Ganti SA_EMAIL_ADDRESS dengan alamat email akun layanan.
    • Anda dapat menentukan beberapa definisi keamanan dalam konfigurasi API, tetapi setiap definisi harus memiliki x-google-issuer yang berbeda. Jika telah membuat akun layanan terpisah untuk setiap layanan panggilan, Anda dapat membuat definisi keamanan untuk setiap akun layanan, misalnya:
    securityDefinitions:
  service-1:
    authorizationUrl: ""
    flow: "implicit"
    type: "oauth2"
    x-google-issuer: "service-1@example-project-12345.iam.gserviceaccount.com"
    x-google-jwks_uri: "https://www.googleapis.com/robot/v1/metadata/x509/service-1@example-project-12345.iam.gserviceaccount.com"
  service-2:
    authorizationUrl: ""
    flow: "implicit"
    type: "oauth2"
    x-google-issuer: "service-2@example-project-12345.iam.gserviceaccount.com"
    x-google-jwks_uri: "https://www.googleapis.com/robot/v1/metadata/x509/service-2@example-project-12345.iam.gserviceaccount.com"

  2. Secara opsional, tambahkan x-google-audiences ke bagian securityDefinitions. Jika Anda tidak menambahkan x-google-audiences, API Gateway mewajibkan klaim "aud" (audiens) dalam JWT dalam format https://SERVICE_NAME, dengan SERVICE_NAME adalah nama layanan API Gateway, yang telah Anda konfigurasikan di kolom host dalam dokumen OpenAPI.

  3. Tambahkan bagian security di level atas file (tidak diindentasi atau bertingkat) untuk diterapkan ke seluruh API, atau di level metode untuk diterapkan ke metode tertentu. Jika Anda menggunakan bagian security di tingkat API dan di tingkat metode, setelan tingkat metode akan menggantikan setelan tingkat API.

    security:
  - DEFINITION_NAME: []
    • Ganti DEFINITION_NAME dengan nama yang Anda gunakan di bagian securityDefinitions.

    • Jika Anda memiliki lebih dari satu definisi di bagian securityDefinitions, tambahkan di bagian security, misalnya:

      security:
  - service-1: []
  - service-2: []

  4. Deploy konfigurasi API yang telah diperbarui.

Sebelum meneruskan permintaan ke API Anda, API Gateway akan memverifikasi:

  • Tanda tangan JWT menggunakan kunci publik, yang terletak di URI yang ditentukan di kolom x-google-jwks_uri dalam konfigurasi API Anda.
  • Klaim "iss" (penerbit) di JWT cocok dengan nilai yang ditentukan di kolom x-google-issuer.
  • Klaim "aud" (audiens) di JWT berisi nama layanan API Gateway Anda atau cocok dengan salah satu nilai yang Anda tentukan di kolom x-google-audiences.
  • Bahwa masa berlaku token belum berakhir dengan menggunakan klaim "exp" (waktu habis masa berlaku).

Untuk informasi selengkapnya tentang x-google-issuer, x-google-jwks_uri, dan x-google-audiences, lihat ekstensi OpenAPI.

Membuat permintaan yang diautentikasi ke API API Gateway

Untuk membuat permintaan yang diautentikasi, layanan panggilan mengirim JWT yang ditandatangani oleh akun layanan yang Anda tentukan dalam konfigurasi API. Layanan panggilan harus:

  1. Buat JWT dan tanda tangani dengan kunci pribadi akun layanan.
  2. Kirim JWT yang ditandatangani dalam permintaan ke API.

Contoh kode berikut menunjukkan proses ini untuk bahasa tertentu. Untuk membuat permintaan yang diautentikasi dalam bahasa lain, lihat jwt.io untuk mengetahui daftar library yang didukung.

  1. Di layanan panggilan, tambahkan fungsi berikut dan teruskan parameter berikut:
    Java
    • saKeyfile: Jalur lengkap ke file kunci pribadi akun layanan.
    • saEmail: Alamat email akun layanan.
    • audience: Jika Anda menambahkan kolom x-google-audiences ke konfigurasi API, tetapkan audience ke salah satu nilai yang ditentukan untuk x-google-audiences. Jika tidak, tetapkan audience ke https://SERVICE_NAME, dengan SERVICE_NAME adalah nama layanan API Gateway Anda.
    • expiryLength: Waktu habis masa berlaku JWT, dalam detik.
    Python
    • sa_keyfile: Jalur lengkap ke file kunci pribadi akun layanan.
    • sa_email: Alamat email akun layanan.
    • audience: Jika Anda menambahkan kolom x-google-audiences ke konfigurasi API, tetapkan audience ke salah satu nilai yang ditentukan untuk x-google-audiences. Jika tidak, tetapkan audience ke https://SERVICE_NAME, dengan SERVICE_NAME adalah nama layanan API Gateway Anda.
    • expiry_length: Waktu habis masa berlaku JWT, dalam detik.
    Go
    • saKeyfile: Jalur lengkap ke file kunci pribadi akun layanan.
    • saEmail: Alamat email akun layanan.
    • audience: Jika Anda menambahkan kolom x-google-audiences ke konfigurasi API, tetapkan audience ke salah satu nilai yang ditentukan untuk x-google-audiences. Jika tidak, tetapkan audience ke https://SERVICE_NAME, dengan SERVICE_NAME adalah nama layanan API Gateway Anda.
    • expiryLength: Waktu habis masa berlaku JWT, dalam detik.

    Fungsi ini membuat JWT, menandatanganinya menggunakan file kunci pribadi, dan menampilkan JWT yang ditandatangani.

    Java
    /**
 * Generates a signed JSON Web Token using a Google API Service Account
 * utilizes com.auth0.jwt.
 */
public static String generateJwt(final String saKeyfile, final String saEmail,
    final String audience, final int expiryLength)
    throws FileNotFoundException, IOException {

  Date now = new Date();
  Date expTime = new Date(System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(expiryLength));

  // Build the JWT payload
  JWTCreator.Builder token = JWT.create()
      .withIssuedAt(now)
      // Expires after 'expiryLength' seconds
      .withExpiresAt(expTime)
      // Must match 'issuer' in the security configuration in your
      // swagger spec (e.g. service account email)
      .withIssuer(saEmail)
      // Must be either your Endpoints service name, or match the value
      // specified as the 'x-google-audience' in the OpenAPI document
      .withAudience(audience)
      // Subject and email should match the service account's email
      .withSubject(saEmail)
      .withClaim("email", saEmail);

  // Sign the JWT with a service account
  FileInputStream stream = new FileInputStream(saKeyfile);
  ServiceAccountCredentials cred = ServiceAccountCredentials.fromStream(stream);
  RSAPrivateKey key = (RSAPrivateKey) cred.getPrivateKey();
  Algorithm algorithm = Algorithm.RSA256(null, key);
  return token.sign(algorithm);
}
    Python
    def generate_jwt(
    sa_keyfile,
    sa_email="account@project-id.iam.gserviceaccount.com",
    audience="your-service-name",
    expiry_length=3600,
):
    """Generates a signed JSON Web Token using a Google API Service Account."""

    now = int(time.time())

    # build payload
    payload = {
        "iat": now,
        # expires after 'expiry_length' seconds.
        "exp": now + expiry_length,
        # iss must match 'issuer' in the security configuration in your
        # swagger spec (e.g. service account email). It can be any string.
        "iss": sa_email,
        # aud must be either your Endpoints service name, or match the value
        # specified as the 'x-google-audience' in the OpenAPI document.
        "aud": audience,
        # sub and email should match the service account's email address
        "sub": sa_email,
        "email": sa_email,
    }

    # sign with keyfile
    signer = google.auth.crypt.RSASigner.from_service_account_file(sa_keyfile)
    jwt = google.auth.jwt.encode(signer, payload)

    return jwt
    Go
    
// generateJWT creates a signed JSON Web Token using a Google API Service Account.
func generateJWT(saKeyfile, saEmail, audience string, expiryLength int64) (string, error) {
	now := time.Now().Unix()

	// Build the JWT payload.
	jwt := &jws.ClaimSet{
		Iat: now,
		// expires after 'expiryLength' seconds.
		Exp: now + expiryLength,
		// Iss must match 'issuer' in the security configuration in your
		// swagger spec (e.g. service account email). It can be any string.
		Iss: saEmail,
		// Aud must be either your Endpoints service name, or match the value
		// specified as the 'x-google-audience' in the OpenAPI document.
		Aud: audience,
		// Sub and Email should match the service account's email address.
		Sub:           saEmail,
		PrivateClaims: map[string]interface{}{"email": saEmail},
	}
	jwsHeader := &jws.Header{
		Algorithm: "RS256",
		Typ:       "JWT",
	}

	// Extract the RSA private key from the service account keyfile.
	sa, err := ioutil.ReadFile(saKeyfile)
	if err != nil {
		return "", fmt.Errorf("Could not read service account file: %w", err)
	}
	conf, err := google.JWTConfigFromJSON(sa)
	if err != nil {
		return "", fmt.Errorf("Could not parse service account JSON: %w", err)
	}
	block, _ := pem.Decode(conf.PrivateKey)
	parsedKey, err := x509.ParsePKCS8PrivateKey(block.Bytes)
	if err != nil {
		return "", fmt.Errorf("private key parse error: %w", err)
	}
	rsaKey, ok := parsedKey.(*rsa.PrivateKey)
	// Sign the JWT with the service account's private key.
	if !ok {
		return "", errors.New("private key failed rsa.PrivateKey type assertion")
	}
	return jws.Encode(jwsHeader, jwt, rsaKey)
}
  2. Di layanan panggilan, tambahkan fungsi berikut untuk mengirim JWT yang ditandatangani di header Authorization: Bearer dalam permintaan ke API:
    Java
    /**
 * Makes an authorized request to the endpoint.
 */
public static String makeJwtRequest(final String signedJwt, final URL url)
    throws IOException, ProtocolException {

  HttpURLConnection con = (HttpURLConnection) url.openConnection();
  con.setRequestMethod("GET");
  con.setRequestProperty("Content-Type", "application/json");
  con.setRequestProperty("Authorization", "Bearer " + signedJwt);

  InputStreamReader reader = new InputStreamReader(con.getInputStream());
  BufferedReader buffReader = new BufferedReader(reader);

  String line;
  StringBuilder result = new StringBuilder();
  while ((line = buffReader.readLine()) != null) {
    result.append(line);
  }
  buffReader.close();
  return result.toString();
}
    Python
    def make_jwt_request(signed_jwt, url="https://your-endpoint.com"):
    """Makes an authorized request to the endpoint"""
    headers = {
        "Authorization": "Bearer {}".format(signed_jwt.decode("utf-8")),
        "content-type": "application/json",
    }
    response = requests.get(url, headers=headers)
    print(response.status_code, response.content)
    response.raise_for_status()
    Go
    
// makeJWTRequest sends an authorized request to your deployed endpoint.
func makeJWTRequest(signedJWT, url string) (string, error) {
	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return "", fmt.Errorf("failed to create HTTP request: %w", err)
	}
	req.Header.Add("Authorization", "Bearer "+signedJWT)
	req.Header.Add("content-type", "application/json")

	response, err := client.Do(req)
	if err != nil {
		return "", fmt.Errorf("HTTP request failed: %w", err)
	}
	defer response.Body.Close()
	responseData, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return "", fmt.Errorf("failed to parse HTTP response: %w", err)
	}
	return string(responseData), nil
}

Saat Anda mengirim permintaan menggunakan JWT, demi keamanan, sebaiknya Anda meletakkan token autentikasi di header Authorization: Bearer. Contoh:

curl --request POST \
  --header "Authorization: Bearer ${TOKEN}" \
  "${GATEWAY_URL}/echo"

dengan GATEWAY_URL dan TOKEN adalah variabel lingkungan yang masing-masing berisi URL gateway dan token autentikasi yang di-deploy.

Menerima hasil yang diautentikasi di API Anda

API Gateway biasanya meneruskan semua header yang diterimanya. Namun, header ini akan menggantikan header Authorization asli saat alamat backend ditentukan oleh x-google-backend dalam konfigurasi API.

API Gateway akan mengirimkan hasil autentikasi di X-Apigateway-Api-Userinfo ke API backend. Sebaiknya gunakan header ini, bukan header Authorization asli. Header ini dienkode base64url dan berisi payload JWT.

Langkah selanjutnya