Sesuaikan wadah inferensi Anda sendiri untuk Amazon AI SageMaker

Jika Anda tidak dapat menggunakan gambar apa pun yang tercantum di Gambar SageMaker AI Docker yang sudah dibuat sebelumnya Amazon SageMaker AI untuk kasus penggunaan Anda, Anda dapat membuat wadah Docker Anda sendiri dan menggunakannya di dalam SageMaker AI untuk pelatihan dan inferensi. Agar kompatibel dengan SageMaker AI, wadah Anda harus memiliki karakteristik sebagai berikut:

Container Anda harus memiliki daftar server web di port8080.
Container Anda harus menerima POST permintaan ke titik akhir /invocations dan /ping real-time. Permintaan yang Anda kirim ke titik akhir ini harus dikembalikan dengan 60 detik untuk respons reguler dan 8 menit untuk respons streaming, dan memiliki ukuran maksimum 25 MB.

Untuk informasi selengkapnya dan contoh cara membuat wadah Docker Anda sendiri untuk pelatihan dan inferensi dengan SageMaker AI, lihat Membangun wadah algoritme Anda sendiri.

Panduan berikut menunjukkan cara menggunakan JupyterLab ruang dengan Amazon SageMaker Studio Classic untuk mengadaptasi wadah inferensi agar berfungsi dengan hosting SageMaker AI. Contohnya menggunakan server NGINX web, Gunicorn sebagai antarmuka gateway server Python web, dan Flask sebagai kerangka kerja aplikasi web. Anda dapat menggunakan aplikasi yang berbeda untuk menyesuaikan wadah Anda selama memenuhi persyaratan yang tercantum sebelumnya. Untuk informasi selengkapnya tentang menggunakan kode inferensi Anda sendiri, lihatKode Inferensi Kustom dengan Layanan Hosting.

Sesuaikan wadah inferensi Anda

Gunakan langkah-langkah berikut untuk menyesuaikan wadah inferensi Anda sendiri agar berfungsi dengan hosting SageMaker AI. Contoh yang ditunjukkan dalam langkah-langkah berikut menggunakan model Dinamakan Entity Recognition (NER) pra-terlatih yang menggunakan pustaka pemrosesan bahasa alami (NLP) SPacy untuk Python dan berikut ini:

A Dockerfile untuk membangun wadah yang berisi NER model.
Skrip inferensi untuk melayani model. NER

Jika Anda mengadaptasi contoh ini untuk kasus penggunaan Anda, Anda harus menggunakan skrip a Dockerfile dan inferensi yang diperlukan untuk menerapkan dan melayani model Anda.

Buat JupyterLab ruang dengan Amazon SageMaker Studio Classic (opsional).

Anda dapat menggunakan notebook apa pun untuk menjalankan skrip guna menyesuaikan wadah inferensi Anda dengan hosting SageMaker AI. Contoh ini menunjukkan kepada Anda cara menggunakan JupyterLab ruang dalam Amazon SageMaker Studio Classic untuk meluncurkan JupyterLab aplikasi yang dilengkapi dengan gambar Distribusi SageMaker AI. Untuk informasi selengkapnya, lihat SageMaker JupyterLab.

Unggah Docker file dan skrip inferensi.

Buat folder baru di direktori home Anda. Jika Anda menggunakanJupyterLab, di sudut kiri atas, pilih ikon Folder Baru, dan masukkan nama folder untuk memuat. Dockerfile Dalam contoh ini, folder dipanggildocker_test_folder.
Unggah file Dockerfile teks ke folder baru Anda. Berikut ini adalah contoh Dockerfile yang membuat Docker wadah dengan model Named Entity Recognition (NER) yang telah dilatih sebelumnya dari SPacy, aplikasi dan variabel lingkungan yang diperlukan untuk menjalankan contoh:
```
FROM python:3.8

RUN apt-get -y update && apt-get install -y --no-install-recommends \
         wget \
         python3 \
         nginx \
         ca-certificates \
    && rm -rf /var/lib/apt/lists/*

RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \
    pip install flask gevent gunicorn && \
        rm -rf /root/.cache

#pre-trained model package installation
RUN pip install spacy
RUN python -m spacy download en


# Set environment variables
ENV PYTHONUNBUFFERED=TRUE
ENV PYTHONDONTWRITEBYTECODE=TRUE
ENV PATH="/opt/program:${PATH}"

COPY NER /opt/program
WORKDIR /opt/program
```
Dalam contoh kode sebelumnya, variabel lingkungan PYTHONUNBUFFERED Python mencegah buffering aliran output standar, yang memungkinkan pengiriman log lebih cepat ke pengguna. Variabel lingkungan PYTHONDONTWRITEBYTECODE Python mencegah penulisan .pyc file bytecode yang dikompilasi, yang tidak diperlukan untuk kasus penggunaan ini. Variabel lingkungan PATH digunakan untuk mengidentifikasi lokasi train dan serve program saat wadah dipanggil.
Buat direktori baru di dalam folder baru Anda untuk berisi skrip untuk melayani model Anda. Contoh ini menggunakan direktori yang disebutNER, yang berisi skrip berikut yang diperlukan untuk menjalankan contoh ini:
- predictor.py— Python Skrip yang berisi logika untuk memuat dan melakukan inferensi dengan model Anda.
- nginx.conf— Skrip untuk mengkonfigurasi server web.
- serve— Skrip yang memulai server inferensi.
- wsgi.py— Naskah pembantu untuk melayani model.
penting
Jika Anda menyalin skrip inferensi ke buku catatan yang diakhiri .ipynb dan mengganti namanya, skrip Anda mungkin berisi karakter pemformatan yang akan mencegah titik akhir Anda diterapkan. Sebagai gantinya, buat file teks dan ganti namanya.

Unggah skrip untuk membuat model Anda tersedia untuk inferensi. Berikut ini adalah contoh script predictor.py yang disebut yang menggunakan Flask untuk menyediakan /ping dan /invocations endpoint:


from flask import Flask
import flask
import spacy
import os
import json
import logging

#Load in model
nlp = spacy.load('en_core_web_sm') 
#If you plan to use a your own model artifacts, 
#your model artifacts should be stored in /opt/ml/model/ 


# The flask app for serving predictions
app = Flask(__name__)
@app.route('/ping', methods=['GET'])
def ping():
    # Check if the classifier was loaded correctly
    health = nlp is not None
    status = 200 if health else 404
    return flask.Response(response= '\n', status=status, mimetype='application/json')


@app.route('/invocations', methods=['POST'])
def transformation():
    
    #Process input
    input_json = flask.request.get_json()
    resp = input_json['input']
    
    #NER
    doc = nlp(resp)
    entities = [(X.text, X.label_) for X in doc.ents]

    # Transform predictions to JSON
    result = {
        'output': entities
        }

    resultjson = json.dumps(result)
    return flask.Response(response=resultjson, status=200, mimetype='application/json')

/pingTitik akhir dalam contoh skrip sebelumnya mengembalikan kode status 200 jika model dimuat dengan benar, dan 404 jika model dimuat secara tidak benar. /invocationsTitik akhir memproses permintaan yang diformatJSON, mengekstrak bidang input, dan menggunakan NER model untuk mengidentifikasi dan menyimpan entitas dalam entitas variabel. FlaskAplikasi mengembalikan respon yang berisi entitas ini. Untuk informasi lebih lanjut tentang permintaan kesehatan yang diperlukan ini, lihatBagaimana Kontainer Anda Harus Menanggapi Permintaan Pemeriksaan Kesehatan (Ping).

Unggah skrip untuk memulai server inferensi. Contoh skrip berikut memanggil serve menggunakan Gunicorn sebagai server aplikasi, dan Nginx sebagai server web:


#!/usr/bin/env python

# This file implements the scoring service shell. You don't necessarily need to modify it for various
# algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until
# gunicorn exits.
#
# The flask server is specified to be the app object in wsgi.py
#
# We set the following parameters:
#
# Parameter                Environment Variable              Default Value
# ---------                --------------------              -------------
# number of workers        MODEL_SERVER_WORKERS              the number of CPU cores
# timeout                  MODEL_SERVER_TIMEOUT              60 seconds

import multiprocessing
import os
import signal
import subprocess
import sys

cpu_count = multiprocessing.cpu_count()

model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60)
model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count))

def sigterm_handler(nginx_pid, gunicorn_pid):
    try:
        os.kill(nginx_pid, signal.SIGQUIT)
    except OSError:
        pass
    try:
        os.kill(gunicorn_pid, signal.SIGTERM)
    except OSError:
        pass

    sys.exit(0)

def start_server():
    print('Starting the inference server with {} workers.'.format(model_server_workers))


    # link the log streams to stdout/err so they will be logged to the container logs
    subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log'])
    subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log'])

    nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf'])
    gunicorn = subprocess.Popen(['gunicorn',
                                 '--timeout', str(model_server_timeout),
                                 '-k', 'sync',
                                 '-b', 'unix:/tmp/gunicorn.sock',
                                 '-w', str(model_server_workers),
                                 'wsgi:app'])

    signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid))

    # Exit the inference server upon exit of either subprocess
    pids = set([nginx.pid, gunicorn.pid])
    while True:
        pid, _ = os.wait()
        if pid in pids:
            break

    sigterm_handler(nginx.pid, gunicorn.pid)
    print('Inference server exiting')

# The main routine to invoke the start function.

if __name__ == '__main__':
    start_server()

Contoh skrip sebelumnya mendefinisikan fungsi penangan sinyalsigterm_handler, yang mematikan Nginx dan Gunicorn sub-proses ketika menerima sinyal. SIGTERM start_serverFungsi memulai penangan sinyal, memulai dan memantau dan Gunicorn sub-proses, Nginx dan menangkap aliran log.

Unggah skrip untuk mengkonfigurasi server web Anda. Contoh skrip berikut disebutnginx.conf, mengkonfigurasi server Nginx web menggunakan Gunicorn sebagai server aplikasi untuk melayani model Anda untuk inferensi:


worker_processes 1;
daemon off; # Prevent forking


pid /tmp/nginx.pid;
error_log /var/log/nginx/error.log;

events {
  # defaults
}

http {
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  access_log /var/log/nginx/access.log combined;
  
  upstream gunicorn {
    server unix:/tmp/gunicorn.sock;
  }

  server {
    listen 8080 deferred;
    client_max_body_size 5m;

    keepalive_timeout 5;
    proxy_read_timeout 1200s;

    location ~ ^/(ping|invocations) {
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header Host $http_host;
      proxy_redirect off;
      proxy_pass http://gunicorn;
    }

    location / {
      return 404 "{}";
    }
  }
}

Contoh skrip sebelumnya mengkonfigurasi Nginx untuk berjalan di latar depan, menetapkan lokasi untuk menangkaperror_log, dan mendefinisikan upstream sebagai kaus kaki soket Gunicorn server. Server mengkonfigurasi blok server untuk mendengarkan pada port8080, menetapkan batas pada ukuran badan permintaan klien dan nilai batas waktu. Server memblokir, meneruskan permintaan yang berisi salah satu /ping atau /invocations jalur ke Gunicornserver http://gunicorn, dan mengembalikan 404 kesalahan untuk jalur lain.

Unggah skrip lain yang diperlukan untuk melayani model Anda. Contoh ini memerlukan contoh script berikut yang dipanggil wsgi.py untuk membantu Gunicorn menemukan aplikasi Anda:


import predictor as myapp

# This is just a simple wrapper for gunicorn to find your app.
# If you want to change the algorithm file, simply change "predictor" above to the
# new file.

app = myapp.app

Dari folderdocker_test_folder, struktur direktori Anda harus berisi Dockerfile dan folderNER. NERFolder harus berisi filenginx.conf,predictor.py,serve, dan wsgi.py sebagai berikut:

The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.

Bangun wadah Anda sendiri.

Dari folderdocker_test_folder, buat Docker wadah Anda. Perintah contoh berikut akan membangun Docker wadah yang dikonfigurasi dalam AndaDockerfile:
```
! docker build -t byo-container-test .
```
Perintah sebelumnya akan membangun wadah yang disebut byo-container-test di direktori kerja saat ini. Untuk informasi selengkapnya tentang parameter Docker build, lihat Argumen build.
catatan
Jika Anda mendapatkan pesan kesalahan berikut yang Docker tidak dapat menemukanDockerfile, pastikan Dockerfile memiliki nama yang benar dan telah disimpan ke direktori.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker_test_folder/Dockerfile: no such file or directory
```
Dockermencari file yang secara khusus dipanggil Dockerfile tanpa ekstensi apa pun dalam direktori saat ini. Jika Anda menamakannya sesuatu yang lain, Anda dapat meneruskan nama file secara manual dengan flag -f. Misalnya, jika Anda menamai Dockerfile asDockerfile-text.txt, buat Docker penampung Anda menggunakan -f bendera yang diikuti oleh file Anda sebagai berikut:
```
! docker build -t byo-container-test -f Dockerfile-text.txt .
```

Dorong Docker Gambar Anda ke Amazon Elastic Container Registry (Amazon ECR)

Di sel notebook, dorong Docker gambar Anda ke ECR. Contoh kode berikut menunjukkan cara membangun container Anda secara lokal, login dan mendorongnya ke ECR:


%%sh
# Name of algo -> ECR
algorithm_name=sm-pretrained-spacy

#make serve executable
chmod +x NER/serve
account=$(aws sts get-caller-identity --query Account --output text)
# Region, defaults to us-west-2
region=$(aws configure get region)
region=${region:-us-east-1}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
    aws ecr create-repository --repository-name "${algorithm_name}" > /dev/nullfi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.

docker build  -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}

docker push ${fullname}

Dalam contoh sebelumnya menunjukkan bagaimana melakukan langkah-langkah berikut yang diperlukan untuk mendorong contoh wadah Docker ke ECR:

Tentukan nama algoritma sebagaism-pretrained-spacy.
Buat serve file di dalam NER folder dapat dieksekusi.
Mengatur Wilayah AWS.
Buat ECR jika belum ada.
Login ke ECR.
Bangun Docker wadah secara lokal.
Dorong Docker gambar ke ECR.

Siapkan klien SageMaker AI

Jika Anda ingin menggunakan layanan hosting SageMaker AI untuk inferensi, Anda harus membuat model, membuat konfigurasi titik akhir, dan membuat titik akhir. Untuk mendapatkan kesimpulan dari titik akhir Anda, Anda dapat menggunakan klien SageMaker AI boto3 Runtime untuk memanggil titik akhir Anda. Kode berikut menunjukkan kepada Anda cara mengatur klien SageMaker AI dan klien SageMaker Runtime menggunakan klien SageMaker AI boto3:
```
import boto3
from sagemaker import get_execution_role

sm_client = boto3.client(service_name='sagemaker')
runtime_sm_client = boto3.client(service_name='sagemaker-runtime')

account_id = boto3.client('sts').get_caller_identity()['Account']
region = boto3.Session().region_name

#used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container, 
#in this example case we will not be making use of S3 to store the model artifacts
#s3_bucket = '<S3Bucket>'

role = get_execution_role()
```
Dalam contoh kode sebelumnya, bucket Amazon S3 tidak digunakan, tetapi dimasukkan sebagai komentar untuk menunjukkan cara menyimpan artefak model.

Jika Anda menerima kesalahan izin setelah menjalankan contoh kode sebelumnya, Anda mungkin perlu menambahkan izin ke peran IAM Anda. Untuk informasi selengkapnya tentang peran IAM, lihatManajer SageMaker Peran Amazon. Untuk informasi selengkapnya tentang menambahkan izin ke peran Anda saat ini, lihatKebijakan terkelola untuk Amazon S3.

Buat model Anda.

Jika Anda ingin menggunakan layanan hosting SageMaker AI untuk inferensi, Anda harus membuat model di SageMaker AI. Contoh kode berikut menunjukkan cara membuat spaCy NER model di dalam SageMaker AI:


from time import gmtime, strftime

model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
# MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts. 
# Here we are not  
#model_url = 's3://{}/spacy/'.format(s3_bucket) 

container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region)
instance_type = 'ml.c5d.18xlarge'

print('Model name: ' + model_name)
#print('Model data Url: ' + model_url)
print('Container image: ' + container)

container = {
'Image': container
}

create_model_response = sm_client.create_model(
    ModelName = model_name,
    ExecutionRoleArn = role,
    Containers = [container])

print("Model Arn: " + create_model_response['ModelArn'])

Contoh kode sebelumnya menunjukkan cara mendefinisikan penggunaan s3_bucket jika Anda model_url menggunakan bucket Amazon S3 dari komentar di Langkah 5, dan mendefinisikan URI ECR untuk image container. Contoh kode sebelumnya mendefinisikan ml.c5d.18xlarge sebagai tipe instance. Anda juga dapat memilih jenis instance yang berbeda. Untuk informasi selengkapnya tentang jenis instans yang tersedia, lihat jenis EC2 instans Amazon.

Dalam contoh kode sebelumnya, Poin Image utama ke URI gambar kontainer. create_model_responseDefinisi menggunakan create_model method untuk membuat model, dan mengembalikan nama model, peran dan daftar yang berisi informasi kontainer.

Contoh output dari script sebelumnya berikut:


Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS
Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/
Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest
Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS

Konfigurasikan dan buat titik akhir

Untuk menggunakan hosting SageMaker AI untuk inferensi, Anda juga harus mengonfigurasi dan membuat titik akhir. SageMaker AI akan menggunakan titik akhir ini untuk inferensi. Contoh konfigurasi berikut menunjukkan cara membuat dan mengonfigurasi titik akhir dengan jenis instans dan nama model yang Anda tentukan sebelumnya:
```
endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint config name: ' + endpoint_config_name)

create_endpoint_config_response = sm_client.create_endpoint_config(
    EndpointConfigName = endpoint_config_name,
    ProductionVariants=[{
        'InstanceType': instance_type,
        'InitialInstanceCount': 1,
        'InitialVariantWeight': 1,
        'ModelName': model_name,
        'VariantName': 'AllTraffic'}])
        
print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn'])
```
Dalam contoh konfigurasi sebelumnya, create_endpoint_config_response mengaitkan model_name dengan nama konfigurasi titik akhir unik endpoint_config_name yang dibuat dengan stempel waktu.

Contoh output dari script sebelumnya berikut:
```
Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS
Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS
```
Untuk informasi selengkapnya tentang kesalahan titik akhir, lihat Mengapa titik akhir Amazon SageMaker AI saya masuk ke status gagal saat saya membuat atau memperbarui titik akhir?

Buat titik akhir dan tunggu titik akhir dalam layanan.

Contoh kode berikut membuat titik akhir menggunakan konfigurasi dari contoh konfigurasi sebelumnya dan menerapkan model:


%%time

import time

endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime())
print('Endpoint name: ' + endpoint_name)

create_endpoint_response = sm_client.create_endpoint(
    EndpointName=endpoint_name,
    EndpointConfigName=endpoint_config_name)
print('Endpoint Arn: ' + create_endpoint_response['EndpointArn'])

resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
status = resp['EndpointStatus']
print("Endpoint Status: " + status)

print('Waiting for {} endpoint to be in service...'.format(endpoint_name))
waiter = sm_client.get_waiter('endpoint_in_service')
waiter.wait(EndpointName=endpoint_name)

Dalam contoh kode sebelumnya, create_endpoint metode membuat titik akhir dengan nama titik akhir yang dihasilkan yang dibuat dalam contoh kode sebelumnya, dan mencetak Nama Sumber Daya Amazon dari titik akhir. describe_endpointMetode mengembalikan informasi tentang endpoint dan statusnya. Seorang pelayan SageMaker AI menunggu titik akhir dalam pelayanan.

Uji titik akhir Anda.

Setelah titik akhir Anda dalam layanan, kirim permintaan pemanggilan ke titik akhir Anda. Contoh kode berikut menunjukkan cara mengirim permintaan pengujian ke titik akhir Anda:
```
import json
content_type = "application/json"
request_body = {"input": "This is a test with NER in America with \
    Amazon and Microsoft in Seattle, writing random stuff."}

#Serialize data for endpoint
#data = json.loads(json.dumps(request_body))
payload = json.dumps(request_body)

#Endpoint invocation
response = runtime_sm_client.invoke_endpoint(
EndpointName=endpoint_name,
ContentType=content_type,
Body=payload)

#Parse results
result = json.loads(response['Body'].read().decode())['output']
result
```
Dalam contoh kode sebelumnya, metode ini json.dumps membuat serial request_body menjadi string yang diformat dalam JSON dan menyimpannya dalam payload variabel. Kemudian klien SageMaker AI Runtime menggunakan metode titik akhir pemanggilan untuk mengirim muatan ke titik akhir Anda. Hasilnya berisi respons dari titik akhir Anda setelah mengekstraksi bidang output.

Contoh kode sebelumnya harus mengembalikan output berikut:
```
[['NER', 'ORG'],
 ['America', 'GPE'],
 ['Amazon', 'ORG'],
 ['Microsoft', 'ORG'],
 ['Seattle', 'GPE']]
```
Hapus titik akhir Anda

Setelah Anda menyelesaikan pemanggilan, hapus titik akhir Anda untuk menghemat sumber daya. Contoh kode berikut menunjukkan cara menghapus titik akhir Anda:
```
sm_client.delete_endpoint(EndpointName=endpoint_name)
sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name)
sm_client.delete_model(ModelName=model_name)
```
Untuk buku catatan lengkap yang berisi kode dalam contoh ini, lihat BYOC-Single-model.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Gunakan registri Docker yang memerlukan otentikasi untuk pelatihan

Pembuatan kontainer dengan algoritme dan model Anda sendiri

Sesuaikan wadah inferensi Anda sendiri untuk Amazon AI SageMaker

Sesuaikan wadah inferensi Anda

penting

catatan

Konfigurasikan dan buat titik akhir

Buat titik akhir dan tunggu titik akhir dalam layanan.