확장 가능한 TensorFlow 추론 시스템 배포

Last reviewed 2023-11-02 UTC

이 문서에서는 확장 가능한 TensorFlow 추론 시스템에 설명된 참조 아키텍처를 배포하는 방법을 설명합니다.

이 시리즈는 TensorFlow 및 NVIDIA TensorRT를 포함하여 Google Kubernetes Engine 및 머신러닝(ML) 프레임워크에 익숙한 개발자를 대상으로 합니다.

이 배포를 완료한 후에는 TensorFlow 추론 시스템의 성능 측정 및 조정을 참조하세요.

아키텍처

다음 다이어그램은 추론 시스템의 아키텍처를 보여줍니다.

추론 시스템의 아키텍처입니다.

Cloud Load Balancing은 가장 가까운 GKE 클러스터로 요청 트래픽을 전송합니다. 클러스터에는 각 노드에 대한 포드가 포함됩니다. 각 포드에서 Triton 추론 서버는 추론 서비스(ResNet-50 모델 지원)를 제공하고 NVIDIA T4 GPU는 성능을 향상시켜 줍니다. 클러스터의 모니터링 서버는 GPU 사용률 및 메모리 사용량에 대한 측정항목 데이터를 수집합니다.

자세한 내용은 확장 가능한 TensorFlow 추론 시스템을 참조하세요.

목표

사전 학습된 ResNet-50 모델 다운로드 및 TensorRT(TF-TRT)와 TensorFlow 통합을 사용하여 최적화 적용
NVIDIA Triton 추론 서버에서 ResNet-50 모델 지원
Prometheus 및 Grafana를 사용하여 Triton의 모니터링 시스템 빌드
Locust를 사용하여 부하 테스트 도구 빌드

비용

이 배포에서는 NVIDIA T4 GPU 외에도 다음 청구 가능한 Google Cloud 구성요소를 사용합니다.

프로젝트 사용량을 기준으로 예상 비용을 산출하려면 가격 계산기를 사용하세요.

이 배포를 마친 후에 만든 리소스를 삭제하지 마세요. 배포를 측정하고 조정할 때 이러한 리소스가 필요합니다.

시작하기 전에

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Google Cloud 프로젝트에 결제가 사용 설정되어 있는지 확인합니다.

GKE API 사용 설정
API 사용 설정

TF-TRT를 사용하여 최적화된 모델 빌드

이 섹션에서는 작업 환경을 만들고 사전 학습된 모델을 최적화합니다.

사전 학습된 모델은 gs://cloud-tpu-test-datasets/fake_imagenet/에서 가짜 데이터 세트를 사용합니다. 또한 gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/의 Cloud Storage 위치에 사전 학습된 모델의 복사본이 있습니다.

작업 환경 만들기

작업 환경을 위해서는 Deep Learning VM Image를 사용해서 Compute Engine 인스턴스를 만듭니다. 이 인스턴스에서 TensorRT로 ResNet-50 모델을 최적화하고 양자화합니다.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

working-vm이라는 인스턴스를 배포합니다.

gcloud config set project PROJECT_ID
gcloud config set compute/zone us-west1-b
gcloud compute instances create working-vm \
    --scopes cloud-platform \
    --image-family common-cu113 \
    --image-project deeplearning-platform-release \
    --machine-type n1-standard-8 \
    --min-cpu-platform="Intel Skylake" \
    --accelerator=type=nvidia-tesla-t4,count=1 \
    --boot-disk-size=200GB \
    --maintenance-policy=TERMINATE \
    --metadata="install-nvidia-driver=True"

PROJECT_ID를 이전에 만든 Google Cloud 프로젝트의 ID로 바꿉니다.

이 명령어는 NVIDIA T4를 사용해서 Compute Engine 인스턴스를 실행합니다. 처음 부팅할 때 TensorRT 5.1.5와 호환되는 NVIDIA GPU 드라이버가 자동으로 설치됩니다.

다른 최적화로 모델 파일 만들기

이 섹션에서는 TF-TRT를 사용하여 원래의 ResNet-50 모델에 다음 최적화를 적용합니다.

그래프 최적화
그래프 최적화를 사용하여 FP16으로 변환
그래프 최적화와 INT8을 사용하여 양자화

이러한 최적화에 대한 자세한 내용은 성능 최적화를 참조하세요.

Google Cloud 콘솔에서 Compute Engine > VM 인스턴스로 이동합니다.

VM 인스턴스로 이동

앞에서 만든 working-vm 인스턴스가 표시됩니다.
인스턴스의 터미널 콘솔을 열려면 SSH를 클릭합니다.

이 터미널을 사용해서 이 문서의 나머지 명령어를 실행합니다.

터미널에서 필요한 저장소를 복제하고 현재 디렉터리를 변경합니다.

cd $HOME
git clone https://github.com/GoogleCloudPlatform/gke-tensorflow-inference-system-tutorial
cd gke-tensorflow-inference-system-tutorial/server

사전 학습된 ResNet-50 모델을 로컬 디렉터리로 다운로드합니다.

mkdir -p models/resnet/original/00001
gcloud storage cp gs://solutions-public-assets/tftrt-tutorial/resnet/export/1584366419/* models/resnet/original/00001 --recursive

TF-TRT용 최적화 도구가 포함된 컨테이너 이미지를 빌드합니다.
```
docker build ./ -t trt-optimizer
docker image list
```
마지막 명령어는 저장소 테이블을 표시합니다.
테이블의 tft-optimizer 저장소 행에서 이미지 ID를 복사합니다.

원본 모델에 최적화(그래프 최적화, FP16으로 변환, INT8을 사용하여 양자화)를 적용합니다.

export IMAGE_ID=IMAGE_ID

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP32' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='FP16' \
    --batch-size=64

nvidia-docker run --rm \
    -v `pwd`/models/:/workspace/models ${IMAGE_ID} \
    --input-model-dir='models/resnet/original/00001' \
    --output-dir='models/resnet' \
    --precision-mode='INT8' \
    --batch-size=64 \
    --calib-image-dir='gs://cloud-tpu-test-datasets/fake_imagenet/' \
    --calibration-epochs=10

IMAGE_ID를 이전 단계에서 복사한 tft-optimizer의 이미지 ID로 바꿉니다.

--calib-image-dir 옵션은 사전 학습된 모델에 사용된 학습 데이터의 위치를 지정합니다. 동일한 학습 데이터가 INT8 양자화를 위한 보정에 사용됩니다. 보정 프로세스는 약 5분 정도 걸릴 수 있습니다.

명령어 실행이 완료되면 마지막 출력 줄이 다음과 비슷하게 표시되고, 최적화된 모델은 ./models/resnet에 저장됩니다.

INFO:tensorflow:SavedModel written to: models/resnet/INT8/00001/saved_model.pb

디렉터리 구조는 다음과 비슷합니다.

models
└── resnet
    ├── FP16
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── FP32
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    ├── INT8
    │   └── 00001
    │       ├── saved_model.pb
    │       └── variables
    └── original
        └── 00001
            ├── saved_model.pb
            └── variables
                ├── variables.data-00000-of-00001
                └── variables.index

다음 표에는 디렉터리와 최적화 간의 관계가 요약되어 있습니다.

디렉터리	최적화
`FP16`	그래프 최적화 외에 FP16으로 변환
`FP32`	그래프 최적화
`INT8`	그래프 최적화 외에 INT8을 사용한 양자화
`original`	원본 모델(TF-TRT를 사용한 최적화 없음)

추론 서버 배포

이 섹션에서는 5개 모델로 Triton 서버를 배포합니다. 먼저 이전 섹션에서 만든 모델 바이너리를 Cloud Storage에 업로드합니다. 그런 다음 GKE 클러스터를 만들고 클러스터에 Triton 서버를 배포합니다.

모델 바이너리 업로드

SSH 터미널에서 모델 바이너리와 config.pbtxt 구성 파일을 스토리지 버킷에 업로드합니다.

export PROJECT_ID=PROJECT_ID
export BUCKET_NAME=${PROJECT_ID}-models

mkdir -p original/1/model/
cp -r models/resnet/original/00001/* original/1/model/
cp original/config.pbtxt original/1/model/
cp original/imagenet1k_labels.txt original/1/model/

mkdir -p tftrt_fp32/1/model/
cp -r models/resnet/FP32/00001/* tftrt_fp32/1/model/
cp tftrt_fp32/config.pbtxt tftrt_fp32/1/model/
cp tftrt_fp32/imagenet1k_labels.txt tftrt_fp32/1/model/

mkdir -p tftrt_fp16/1/model/
cp -r models/resnet/FP16/00001/* tftrt_fp16/1/model/
cp tftrt_fp16/config.pbtxt tftrt_fp16/1/model/
cp tftrt_fp16/imagenet1k_labels.txt tftrt_fp16/1/model/

mkdir -p tftrt_int8/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8/1/model/
cp tftrt_int8/config.pbtxt tftrt_int8/1/model/
cp tftrt_int8/imagenet1k_labels.txt tftrt_int8/1/model/

mkdir -p tftrt_int8_bs16_count4/1/model/
cp -r models/resnet/INT8/00001/* tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/config.pbtxt tftrt_int8_bs16_count4/1/model/
cp tftrt_int8_bs16_count4/imagenet1k_labels.txt tftrt_int8_bs16_count4/1/model/

gcloud storage buckets create gs://${BUCKET_NAME}
gcloud storage cp original tftrt_fp32 tftrt_fp16 tftrt_int8 tftrt_int8_bs16_count4 \
    gs://${BUCKET_NAME}/resnet/ --recursive

PROJECT_ID를 이전에 만든 Google Cloud 프로젝트의 ID로 바꿉니다.

다음 조정 매개변수는 config.pbtxt 파일에 지정됩니다.

모델 이름
입력 텐서 이름 및 출력 텐서 이름
각 모델에 GPU 할당
인스턴스 그룹의 일괄 처리 크기 및 개수

예를 들어 original/1/model/config.pbtxt 파일에는 다음 콘텐츠가 포함됩니다.

name: "original"
platform: "tensorflow_savedmodel"
max_batch_size: 64
input {
    name: "input"
    data_type: TYPE_FP32
    format: FORMAT_NHWC
    dims: [ 224, 224, 3 ]
}
output {
    name: "probabilities"
    data_type: TYPE_FP32
    dims: 1000
    label_filename: "imagenet1k_labels.txt"
}
default_model_filename: "model"
instance_group [
  {
    count: 1
    kind: KIND_GPU
  }
]
dynamic_batching {
  preferred_batch_size: [ 64 ]
  max_queue_delay_microseconds: 20000
}

배치 크기 및 인스턴스 그룹 수에 대한 자세한 내용은 성능 최적화를 참조하세요.

다음 표에는 이 섹션에서 배포한 5가지 모델이 요약되어 있습니다.

모델 이름	최적화
`original`	원본 모델(TF-TRT를 사용한 최적화 없음)
`tftrt_fp32`	그래프 최적화 (배치 크기=64, 인스턴스 그룹=1)
`tftrt_fp16`	그래프 최적화 외에 FP16으로 변환 (배치 크기=64, 인스턴스 그룹=1)
`tftrt_int8`	그래프 최적화 외에 INT8을 사용한 양자화 (배치 크기=64, 인스턴스 그룹=1)
`tftrt_int8_bs16_count4`	그래프 최적화 외에 INT8을 사용한 양자화 (배치 크기=16, 인스턴스 그룹=4)

Triton을 사용하여 추론 서버 배포

SSH 터미널에서 GKE 클러스터를 관리하는 인증 ��키지를 설치 및 구성합니다.
```
export USE_GKE_GCLOUD_AUTH_PLUGIN=True
sudo apt-get install google-cloud-sdk-gke-gcloud-auth-plugin
```
NVIDIA T4 GPU를 사용하는 컴퓨팅 노드를 사용해서 GKE 클러스터 및 GPU 노드 풀을 만듭니다.
```
gcloud auth login
gcloud config set compute/zone us-west1-b
gcloud container clusters create tensorrt-cluster \
    --num-nodes=20
gcloud container node-pools create t4-gpu-pool \
    --num-nodes=1 \
    --machine-type=n1-standard-8 \
    --cluster=tensorrt-cluster \
    --accelerator type=nvidia-tesla-t4,count=1
```
--num-nodes 플래그는 GKE 클러스터에 대해 20개 인스턴스를 지정하고 GPU 노드 풀 t4-gpu-pool에 대해 하나의 인스턴스를 지정합니다.

GPU 노드 풀은 NVIDIA T4 GPU가 있는 단일 n1-standard-8 인스턴스로 구성됩니다. NVIDIA T4 GPU는 동일한 인스턴스의 여러 포드에서 공유될 수 없으므로 GPU 인스턴스의 수는 추론 서버 포드의 수보다 크거나 같아야 합니다.

클러스터 정보를 표시합니다.

gcloud container clusters list

출력은 다음과 비슷합니다.

NAME              LOCATION    MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
tensorrt-cluster  us-west1-b  1.14.10-gke.17  XX.XX.XX.XX    n1-standard-1  1.14.10-gke.17  21         RUNNING

노드 풀 정보를 표시합니다.

gcloud container node-pools list --cluster tensorrt-cluster

출력은 다음과 비슷합니다.

NAME          MACHINE_TYPE   DISK_SIZE_GB  NODE_VERSION
default-pool  n1-standard-1  100           1.14.10-gke.17
t4-pool       n1-standard-8  100           1.14.10-gke.17

daemonSet 워크로드를 사용 설정합니다.
```
gcloud container clusters get-credentials tensorrt-cluster
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```
이 명령어는 GPU 노드 풀의 노드에 NVIDIA GPU 드라이버를 로드합니다. 또한 GPU 노드 풀에 새 노드를 추가할 때 드라이버를 자동으로 로드합니다.

클러스터에 추론 서버를 배포합니다.

sed -i.bak "s/YOUR-BUCKET-NAME/${PROJECT_ID}-models/" trtis_deploy.yaml
kubectl create -f trtis_service.yaml
kubectl create -f trtis_deploy.yaml

서비스가 사용 가능해질 때까지 몇 분 정도 기다립니다.

Triton의 clusterIP 주소를 가져와서 환경 변수에 저장합니다.

export TRITON_IP=$(kubectl get svc inference-server \
  -o "jsonpath={.spec['clusterIP']}")
echo ${TRITON_IP}

이 때 추론 서버가 다른 최적화를 사용하여 모델 파일 만들기 섹션에서 만든 4개의 ResNet-50 모델을 제공합니다. 클라이언트가 추론 요청을 전송할 때 사용할 모델을 ��정할 수 있습니다.

Prometheus 및 Grafana로 모니터링 서버 배포

SSH 터미널에서 클러스터에 Prometheus 서버를 배포합니다.

sed -i.bak "s/CLUSTER-IP/${TRITON_IP}/" prometheus-configmap.yml
kubectl create namespace monitoring
kubectl apply -f prometheus-service.yml -n monitoring
kubectl create -f clusterRole.yml
kubectl create -f prometheus-configmap.yml -n monitoring
kubectl create -f prometheus-deployment.yml -n monitoring

Prometheus 서비스의 엔드포인트 URL을 가져옵니다.
```
ip_port=$(kubectl get svc prometheus-service \
  -o "jsonpath={.spec['clusterIP']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"
```
나중에 Grafana를 구성하는 데 사용할 수 있도록 Prometheus 엔드포인트 URL을 기록해 둡니다.

클러스터에 Grafana 서버를 배포합니다.

kubectl create -f grafana-service.yml -n monitoring
kubectl create -f grafana-deployment.yml -n monitoring

모든 서비스가 사용 가능해질 때까지 몇 분 정도 기다립니다.

Grafana 서비스의 엔드포인트 URL을 가져옵니다.

ip_port=$(kubectl get svc grafana-service \
  -o "jsonpath={.status['loadBalancer']['ingress'][0]['ip']}:{.spec['ports'][0]['port']}" -n monitoring)
echo "http://${ip_port}"

다음 단계에서 사용할 수 있도록 Grafana 엔드포인트 URL을 기록해 둡니다.

웹브라우저에서 이전 단계에서 확인한 Grafana URL로 이동합니다.
기본 사용자 ID와 비밀번호(admin 및 admin)를 사용해서 로그인합니다. 메시지가 표시되면 기본 비밀번호를 변경합니다.
첫 번째 데이터 소스 추가를 클릭하고 시계열 데이터베이스 목록에서 Prometheus를 선택합니다.
설정 탭의 URL 필드에서 앞에서 확인한 Prometheus 엔드포인트 URL을 입력합니다.
저장 및 테스트를 클릭한 후 홈 화면으로 돌아갑니다.
nv_gpu_utilization에 대해 모니터링 측정항목을 추가합니다.
1. 첫 번째 대시보드 만들기를 클릭한 후 시각화 추가를 클릭합니다.
2. 데이터 소스 목록에서 Prometheus를 선택합니다.
3. 쿼리 탭의 측정항목 필드에 nv_gpu_utilization을 입력합니다.
4. 패널 옵션 섹션의 제목 필드에 GPU Utilization을 입력한 후 적용을 클릭합니다.
  
  페이지에 GPU 사용률 패널이 표시됩니다.
nv_gpu_memory_used_bytes에 대해 모니터링 측정항목을 추가합니다.
1. 추가를 클릭하고 시각화를 선택합니다.
2. 쿼리 탭의 측정항목 필드에 nv_gpu_memory_used_bytes를 입력합니다.
3. 패널 옵션 섹션의 제목 필드에 GPU Memory Used를 입력한 후 저장을 클릭합니다.
대시보드를 추가하려면 대시보드 저장 패널에서 저장을 클릭합니다.

GPU 사용률 및 사용된 GPU 메모리에 대한 그래프가 표시됩니다.

부하 테스트 도구 배포

이 섹션에서는 Locust 부하 테스트 도구를 GKE에 배포하고 워크로드를 생성하여 추론 서버의 성능을 측정합니다.

SSH 터미널에서 Triton 클라이언트 라이브러리가 포함된 Docker 이미지를 빌드하고 이를 Container Registry에 업로드합니다.

cd ../client
git clone https://github.com/triton-inference-server/server
cd server
git checkout r19.05
sed -i.bak "s/bootstrap.pypa.io\/get-pip.py/bootstrap.pypa.io\/pip\/2.7\/get-pip.py/" Dockerfile.client
docker build -t tritonserver_client -f Dockerfile.client .
gcloud auth configure-docker
docker tag tritonserver_client \
    gcr.io/${PROJECT_ID}/tritonserver_client
docker push gcr.io/${PROJECT_ID}/tritonserver_client

빌드 프로세스는 약 5분 정도 걸릴 수 있습니다. 프로세스가 완료되면 명령 프롬프트가 SSH 터미널에 표시됩니다.

빌드 프로세스가 완료되면 테스트 워크로드를 생성하기 위해 Docker 이미지를 빌드하고, 이를 Container Registry에 업로드합니다.
```
cd ..
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" Dockerfile
docker build -t locust_tester -f Dockerfile .
docker tag locust_tester gcr.io/${PROJECT_ID}/locust_tester
docker push gcr.io/${PROJECT_ID}/locust_tester
```
명령어에서 YOUR-PROJECT-ID를 변경하거나 대체하지 마세요.

이 이미지는 이전 단계에서 만든 이미지에서 빌드됩니다.

Locust 파일 service_master.yaml 및 deployment_master.yaml을 배포합니다.

sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_master.yaml
sed -i.bak "s/CLUSTER-IP-TRTIS/${TRITON_IP}/" deployment_master.yaml

kubectl create namespace locust
kubectl create configmap locust-config --from-literal model=original --from-literal saddr=${TRITON_IP} --from-literal rps=10 -n locust

kubectl apply -f service_master.yaml -n locust
kubectl apply -f deployment_master.yaml -n locust

configmap 리소스는 클라이언트가 추론 요청을 전송하는 머신러닝 모델을 지정하는 데 사용됩니다.

서비스가 사용 가능해질 때까지 몇 분 정도 기다립니다.

locust-master 클라이언트의 clusterIP 주소를 가져와서 이 주소를 환경 변수에 저장합니다.

export LOCUST_MASTER_IP=$(kubectl get svc locust-master -n locust \
    -o "jsonpath={.spec['clusterIP']}")
echo ${LOCUST_MASTER_IP}

Locust 클라이언트를 배포합니다.
```
sed -i.bak "s/YOUR-PROJECT-ID/${PROJECT_ID}/" deployment_slave.yaml
sed -i.bak "s/CLUSTER-IP-LOCUST-MASTER/${LOCUST_MASTER_IP}/" deployment_slave.yaml
kubectl apply -f deployment_slave.yaml -n locust
```
이 명령어는 테스트 워크로드를 생성하는 데 사용할 수 있는 Locust 클라이언트 pod 10개를 배포합니다. 현재 클라이언트 수로는 요청을 충분히 생성할 수 없다면 다음 명령어를 사용하여 pod 수를 변경하면 됩니다.
```
kubectl scale deployment/locust-slave --replicas=20 -n locust
```
기본 클러스터에 복제본 수를 늘리기 위한 충분한 용량이 없으면 GKE 클러스터의 노드 수를 늘리는 것이 좋습니다.
Locust 콘솔의 URL을 복사한 후 웹브라우저에서 이 URL을 엽니다.
```
export LOCUST_IP=$(kubectl get svc locust-master -n locust \
     -o "jsonpath={.status.loadBalancer.ingress[0].ip}")
echo "http://${LOCUST_IP}:8089"
```
Locust 콘솔이 열리고 이로부터 테스트 워크로드를 생성할 수 있습니다.

실행 중인 포드 확인

구성요소가 성공적으로 배포되었는지 확인하려면 포드가 실행 중인지 확인합니다.

SSH 터미널에서 추론 서버 포드를 확인합니다.
```
kubectl get pods
```
출력은 다음과 비슷합니다.
```
NAME                                READY   STATUS    RESTARTS   AGE
inference-server-67786cddb4-qrw6r   1/1     Running   0          83m
```
예상한 출력이 표시되 않으면 Triton을 사용하여 추론 서버 배포의 단계를 완료했는지 확인합니다.

Locust 포드를 확인합니다.

kubectl get pods -n locust

출력은 다음과 비슷합니다.

NAME                                READY   STATUS    RESTARTS   AGE
locust-master-75f6f6d4bc-ttllr      1/1     Running   0          10m
locust-slave-76ddb664d9-8275p       1/1     Running   0          2m36s
locust-slave-76ddb664d9-f45ww       1/1     Running   0          2m36s
locust-slave-76ddb664d9-q95z9       1/1     Running   0          2m36s

예상한 출력이 표시되지 않으면 부하 테스트 도구 배포의 단계를 완료했는지 확인합니다.

모니터링 포드를 확인합니다.

kubectl get pods -n monitoring

출력은 다음과 비슷합니다.

NAME                                     READY   STATUS    RESTARTS   AGE
grafana-deployment-644bbcb84-k6t7v       1/1     Running   0          79m
prometheus-deployment-544b9b9f98-hl7q8   1/1     Running   0          81m

예상한 출력이 표시되지 않으면 Prometheus 및 Grafana를 사용하여 모니터링 서버 배포의 단계를 완료했는지 확인합니다.

이 시리즈의 다음 부분에서는 이 추론 서버 시스템을 사용하여 다양한 최적화가 성능을 어떻게 개선하는지와 이러한 최적화를 해석하는 방법을 ��아봅니다. 다음 단계는 TensorFlow 추론 시스템의 성능 측정 및 조정을 참조하세요.

다음 단계

Google Kubernetes Engine(GKE) 알아보기
Cloud Load Balancing 알아보기
그 밖의 참조 아키텍처, 다이어그램, 튜토리얼, 권장사항을 알아보려면 클라우드 아키텍처 센터를 확인하세요.