Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Autentikasi antarlayanan

OpenAPI | gRPC

Anda dapat menerapkan autentikasi antar-layanan menggunakan akun layanan di layanan gRPC. Halaman ini menunjukkan autentikasi layanan-ke-layanan dengan memandu Anda melalui contoh lengkap, termasuk cara mengonfigurasi Extensible Service Proxy (ESP) di layanan gRPC untuk mendukung permintaan yang diautentikasi dan cara memanggil layanan dari klien gRPC.

Agar layanan dapat melakukan panggilan yang diautentikasi ke Cloud Endpoints API, layanan panggilan harus memiliki akun layanan dan harus mengirim token autentikasi dalam panggilan. Pemanggil harus menggunakan token ID Google atau Token Web JSON (JWT) kustom yang hanya ditandatangani oleh akun layanan pemanggil. ESP memvalidasi bahwa klaim iss dalam JWT cocok dengan setelan issuer dalam konfigurasi layanan. ESP tidak memeriksa izin Identity and Access Management yang telah diberikan pada akun layanan.

Dalam contoh ini, Anda menyiapkan dan menggunakan bentuk autentikasi layanan-ke-layanan yang paling sederhana, dengan klien menggunakan akun layanannya Google Cloud untuk membuat JWT autentikasi. Pendekatan untuk metode autentikasi lainnya serupa, meskipun proses sisi klien untuk mendapatkan token autentikasi yang valid bergantung pada metode autentikasi yang digunakan.

Sebelum memulai

Panduan ini menggunakan contoh Bookstore yang digunakan dalam Tutorial kami.

Clone repo git tempat kode contoh gRPC dihosting:

git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

Ubah direktori kerja Anda:

cd python-docs-samples/endpoints/bookstore-grpc/

Ikuti petunjuk dalam Tutorial untuk menyiapkan project jika Anda belum memilikinya.

Dalam contoh ini, Anda menggunakan deployment ke Google Kubernetes Engine, meskipun penyiapan autentikasi sama untuk Compute Engine.

Dalam contoh ini, ada dua project Google Cloud Platform yang direferensikan:

Project produsen layanan, yaitu project yang memiliki layanan Cloud Endpoints for gRPC.
_Project konsumen_ layanan , yaitu project yang memiliki klien gRPC.

Membuat kunci dan akun layanan konsumen

Catatan: Kunci akun layanan akan berisiko keamanan jika tidak dikelola dengan benar. Anda harus memilih alternatif yang lebih aman untuk kunci akun layanan jika memungkinkan. Jika harus mengautentikasi dengan kunci akun layanan, Anda bertanggung jawab atas keamanan kunci pribadi dan atas operasi lainnya yang dijelaskan dalam Praktik terbaik untuk mengelola kunci akun layanan. Jika Anda tidak dapat membuat kunci akun layanan, pembuatan kunci akun layanan mungkin dinonaktifkan untuk organisasi Anda. Untuk mengetahui informasi selengkapnya, lihat Mengelola resource organisasi yang aman secara default.

Jika Anda mendapatkan kunci akun layanan dari sumber eksternal, Anda harus memvalidasinya sebelum digunakan. Untuk mengetahui informasi selengkapnya, lihat Persyaratan keamanan untuk kredensial yang bersumber dari eksternal.

Untuk membuat kunci dan akun layanan untuk project konsumen:

Di Google Cloud konsol, buka API & layanan.
API &layanan
Pastikan Anda berada di project konsumen.
Di halaman Credentials, di menu drop-down Create Credentials , pilih Service Account Key.
Di halaman Create service account key, jika Anda memiliki akun layanan yang ingin digunakan, pilih akun tersebut. Jika tidak, di menu drop-down akun layanan , pilih akun layanan baru , lalu ketik nama akun.

ID akun layanan yang sesuai akan dibuat untuk Anda. Catat ID-nya, karena diperlukan di bagian berikut. Contoh:
```
service-account-name@YOUR_PROJECT_ID.iam.gserviceaccount.com
```
Klik menu drop-down Role , lalu pilih peran berikut:
- Service Accounts > Service Account User
- Service Accounts > Service Account Token Creator
Pastikan jenis kunci JSON dipilih.
Klik Create. File kunci JSON akun layanan Anda akan didownload ke mesin lokal Anda. Catat lokasinya dan pastikan disimpan dengan aman karena akan digunakan nanti untuk membuat token.

Mengonfigurasi autentikasi untuk layanan

Gunakan project produsen untuk semua langkah di bagian ini.

Menyiapkan autentikasi dalam konfigurasi gRPC API

Autentikasi untuk ESP dikonfigurasi di bagian authentication file YAML konfigurasi gRPC API Anda. Konfigurasi dengan autentikasi untuk layanan contoh ini ada di api_config_auth.yaml.

authentication:
  providers:
  - id: google_service_account
    # Replace SERVICE-ACCOUNT-ID with your service account's email address.
    issuer: SERVICE-ACCOUNT-ID
    jwks_uri: https://www.googleapis.com/robot/v1/metadata/x509/SERVICE-ACCOUNT-ID
  rules:
  # This auth rule will apply to all methods.
  - selector: "*"
    requirements:
      - provider_id: google_service_account

Bagian providers menentukan penyedia autentikasi yang ingin Anda gunakan. Dalam hal ini, Anda ingin menggunakan akun layanan Google sebagai penyedia autentikasi. Bagian rules menentukan bahwa Anda memerlukan token dari penyedia ini untuk mengakses semua metode layanan Anda.

Di salinan file ini dari repo yang di-clone:

Ubah MY_PROJECT_ID ke ID project produsen Anda.
Ubah SERVICE-ACCOUNT-ID di bagian authentication (di nilai issuer dan jwks_uri) ke ID akun layanan konsumen yang Anda catat di bagian sebelumnya. Tindakan ini memberi tahu ESP bahwa Anda ingin memberikan akses ke layanan Anda kepada pengguna yang memberikan token valid dari akun layanan tertentu ini.
Secara opsional, tambahkan jwt_locations di bagian elemen providers. Anda dapat menggunakan nilai ini untuk menentukan lokasi JWT kustom. Lokasi JWT default adalah metadata Authorization (dengan awalan "Bearer ") dan metadata X-Goog-Iap-Jwt-Assertion.

Simpan file untuk langkah berikutnya.

Men-deploy konfigurasi dan layanan

Langkah-langkah ini sama seperti di Memulai gRPC di GKE:

Deploy konfigurasi layanan Anda ke Endpoints: Anda harus melakukannya meskipun Anda melakukannya untuk tutorial, karena ini adalah konfigurasi yang berbeda. Perhatikan nama layanan yang ditampilkan:
```
gcloud endpoints services deploy api_descriptor.pb api_config_auth.yaml --project PRODUCER_PROJECT
```
Buat cluster container dan autentikasi kubectl ke cluster, jika Anda belum melakukannya.
Deploy ESP dan API contoh ke cluster. Jika Anda menggunakan project produsen dan konsumen yang terpisah, pastikan terlebih dahulu bahwa Anda telah menetapkan project yang sesuai dalam alat command line gcloud:
```
gcloud config set project PRODUCER_PROJECT
```

Memanggil metode yang diautentikasi dari klien gRPC

Terakhir, di sisi klien, Anda dapat menggunakan kunci akun layanan untuk membuat token JWT, lalu menggunakan token tersebut untuk memanggil metode Bookstore yang diautentikasi. Pertama, instal persyaratan Python yang sesuai untuk membuat token dan menjalankan klien contoh. Pastikan Anda berada di folder python-docs-samples/endpoints/bookstore-grpc klien yang di-clone, lalu:

virtualenv bookstore-env
source bookstore-env/bin/activate
pip install -r requirements.txt

Membuat token JWT

Dalam contoh ini, Bookstore menggunakan autentikasi layanan-ke-layanan dengan layanan panggilan yang sepenuhnya diautentikasi oleh akun layanannya, sehingga membuat token yang sesuai untuk dikirim dengan permintaan kami menjadi sederhana. Perhatikan bahwa Anda juga dapat mewajibkan autentikasi layanan-ke-layanan yang lebih ketat, dengan token yang dibuat harus diautentikasi lebih lanjut oleh Google (menggunakan token ID Google).

Untuk contoh ini, skrip Python yang disediakan dapat membuat token dari file kunci JSON yang didownload sebelumnya, menggunakan ID pengguna dan email dummy.

#!/usr/bin/env python

# Copyright 2016 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Example of generating a JWT signed from a service account file."""

import argparse
import json
import time

import google.auth.crypt
import google.auth.jwt

"""Max lifetime of the token (one hour, in seconds)."""
MAX_TOKEN_LIFETIME_SECS = 3600


def generate_jwt(service_account_file, issuer, audiences):
    """Generates a signed JSON Web Token using a Google API Service Account."""
    with open(service_account_file) as fh:
        service_account_info = json.load(fh)

    signer = google.auth.crypt.RSASigner.from_string(
        service_account_info["private_key"], service_account_info["private_key_id"]
    )

    now = int(time.time())

    payload = {
        "iat": now,
        "exp": now + MAX_TOKEN_LIFETIME_SECS,
        # aud must match 'audience' in the security configuration in your
        # swagger spec. It can be any string.
        "aud": audiences,
        # iss must match 'issuer' in the security configuration in your
        # swagger spec. It can be any string.
        "iss": issuer,
        # sub and email are mapped to the user id and email respectively.
        "sub": issuer,
        "email": "user@example.com",
    }

    signed_jwt = google.auth.jwt.encode(signer, payload)
    return signed_jwt


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("--file", help="The path to your service account json file.")
    parser.add_argument("--issuer", default="", help="issuer")
    parser.add_argument("--audiences", default="", help="audiences")

    args = parser.parse_args()

    signed_jwt = generate_jwt(args.file, args.issuer, args.audiences)
    print(signed_jwt.decode("utf-8"))

Untuk membuat token menggunakan skrip:

Buat token JWT dan tetapkan ke variabel $JWT_TOKEN:
```
JWT_TOKEN=$(python jwt_token_gen.py \
    --file=[SERVICE_ACCOUNT_FILE] \
    --audiences=[SERVICE_NAME] \
    --issuer=[SERVICE-ACCOUNT-ID])
```
dengan:
- [SERVICE_ACCOUNT_FILE] adalah file kunci JSON akun layanan konsumen yang didownload.
- [SERVICE_NAME] adalah nama layanan Bookstore yang ditampilkan saat Anda men-deploy konfigurasi layanan yang diperbarui ke Endpoints.
- [SERVICE-ACCOUNT-ID] adalah ID akun layanan konsumen lengkap saat Anda membuat akun layanan.

Melakukan panggilan gRPC yang diautentikasi

Langkah terakhir ini menggunakan bookstore_client.py, yang merupakan klien yang sama yang digunakan dalam Tutorial. Untuk melakukan panggilan yang diautentikasi, klien meneruskan JWT sebagai metadata dengan panggilan metodenya.

def run(
    host, port, api_key, auth_token, timeout, use_tls, servername_override, ca_path

Untuk menjalankan contoh:

Gunakan kubectl get services untuk mendapatkan alamat IP eksternal untuk Bookstore yang di-deploy:

#kubectl get services
NAME                 CLUSTER-IP      EXTERNAL-IP      PORT(S)           AGE
echo                 10.11.246.240   104.196.186.92   80/TCP            10d
endpoints            10.11.243.168   104.196.210.50   80/TCP,8090/TCP   10d
esp-grpc-bookstore   10.11.254.34    104.196.60.37    80/TCP            1d
kubernetes           10.11.240.1     <none>           443/TCP           10d

Dalam hal ini, layanan esp-grpc-bookstore dan IP eksternalnya adalah 104.196.60.37.

Tetapkan alamat IP ke variabel EXTERNAL_IP
```
EXTERNAL_IP=104.196.60.37
```
Cantumkan semua rak dari layanan Bookstore:
```
python bookstore_client.py --port=80 --host=$EXTERNAL_IP --auth_token=$JWT_TOKEN
```
Layanan ini menampilkan semua rak di Bookstore saat ini. Anda dapat memeriksanya dua kali dengan tidak memberikan token, atau dengan menentukan ID akun layanan yang salah saat membuat JWT. Perintah akan gagal.

Langkah berikutnya

Memecahkan masalah validasi JWT