

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Contoh kode untuk Throughput yang Disediakan
<a name="prov-thru-code-examples"></a>

Contoh kode berikut menunjukkan cara membuat Provisioned Throughput dan cara mengelola dan memanggilnya, menggunakan dan Python AWS CLI SDK. Anda dapat membuat Provisioned Throughput dari model foundation atau dari model yang telah Anda sesuaikan. Sebelum Anda memulai, lakukan prasyarat berikut:

**Prasyarat**

Contoh berikut menggunakan Amazon Nova Lite model, yang ID modelnya`amazon.nova-lite-v1:0:24k`. Jika Anda belum melakukannya, minta akses ke Amazon Nova Lite dengan mengikuti langkah-langkah di[Kelola akses model menggunakan SDK dan CLI](model-access.md#model-access-modify).

Jika Anda ingin membeli Provisioned Throughput untuk model foundation atau model kustom yang berbeda, Anda harus melakukan hal berikut:

1. Temukan ID model (untuk model pondasi), nama (untuk model kustom), atau ARN (untuk keduanya) dengan melakukan salah satu hal berikut:
   + Jika Anda membeli Provisioned Throughput untuk model foundation, cari ID atau Amazon Resource Name (ARN) model yang mendukung penyediaan dengan salah satu cara berikut:
     + Cari nilai dalam tabel.
     + Kirim [ListFoundationModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListFoundationModels.html)permintaan dan tentukan `byInferenceType` nilainya `PROVISIONED` untuk melihat daftar model yang mendukung penyediaan. Temukan nilai di `modelArn` bidang `modelId` atau.
   + Jika Anda membeli Provisioned Throughput untuk model kustom, cari nama atau Amazon Resource Name (ARN) model yang Anda kustomisasi dengan salah satu cara berikut:
     + Di konsol Amazon Bedrock, pilih **Model khusus** dari panel navigasi kiri. Temukan nama model khusus Anda dalam daftar **Model** atau pilih dan temukan **Model ARN di detail** **Model**.
     + Kirim [ListCustomModels](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_ListCustomModels.html)permintaan dan temukan `modelName` atau `modelArn` nilai model kustom Anda dalam respons.

1. `body`Ubah [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)permintaan dalam contoh di bawah ini agar sesuai dengan format badan model dengan menemukannya di[Parameter permintaan inferensi dan bidang respons untuk model dasar](model-parameters.md).

Pilih tab untuk metode pilihan Anda, lalu ikuti langkah-langkahnya:

------
#### [ AWS CLI ]

1. Kirim [CreateProvisionedModelThroughput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateProvisionedModelThroughput.html)permintaan untuk membuat Throughput Penyediaan tanpa komitmen yang dipanggil*MyPT*, dengan menjalankan perintah berikut di terminal:

   ```
   aws bedrock create-provisioned-model-throughput \
      --model-units 1 \
      --provisioned-model-name MyPT \
      --model-id amazon.nova-lite-v1:0:24k
   ```

1. Respons mengembalikan a`provisioned-model-arn`. Berikan waktu untuk pembuatan selesai. Untuk memeriksa statusnya, kirim [GetProvisionedModelThroughput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_GetProvisionedModelThroughput.html)permintaan dan berikan nama atau ARN dari model yang disediakan sebagai`provisioned-model-id`, dengan menjalankan perintah berikut:

   ```
   aws bedrock get-provisioned-model-throughput \
       --provisioned-model-id ${provisioned-model-arn}
   ```

1. Jalankan inferensi dengan model yang Anda sediakan dengan mengirimkan permintaan. [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) Berikan ARN dari model yang disediakan yang dikembalikan `CreateProvisionedModelThroughput` sebagai tanggapan, sebagai. `model-id` Output ditulis ke file bernama *output.txt* di folder Anda saat ini.

   ```
   aws bedrock-runtime invoke-model \
       --model-id ${provisioned-model-arn} \
       --body '{
                   "messages": [{
                       "role": "user",
                       "content": [{
                           "text": "Hello"
                       }]
                   }],
                   "inferenceConfig": {
                       "temperature":0.7
                   }
               }' \
       --cli-binary-format raw-in-base64-out \
       output.txt
   ```

1. Mengirim [DeleteProvisionedModelThroughput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_DeleteProvisionedModelThroughput.html)permintaan untuk menghapus Provisioned Throughput menggunakan perintah berikut. Anda tidak akan lagi dikenakan biaya untuk Throughput yang Disediakan.

   ```
   aws bedrock delete-provisioned-model-throughput 
     --provisioned-model-id MyPT
   ```

------
#### [ Python (Boto) ]

Cuplikan kode berikut memandu Anda membuat Throughput Terprovisi untuk mendapatkan informasi tentangnya, dan menjalankan Throughput yang Disediakan.

1. Untuk membuat Throughput Penyediaan tanpa komitmen yang dipanggil dan *MyPT* menetapkan ARN dari Provisioned Throughput ke variabel yang disebut, kirim permintaan berikut: *provisioned\$1model\$1arn* [CreateProvisionedModelThroughput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateProvisionedModelThroughput.html)

   ```
   import boto3 
   
   provisioned_model_name = 'MyPT'
   
   bedrock = boto3.client(service_name='bedrock')
   response = bedrock.create_provisioned_model_throughput(
       modelUnits=1,
       provisionedModelName=provisioned_model_name, 
       modelId='amazon.nova-lite-v1:0:24k' 
   )
                           
   provisioned_model_arn = response['provisionedModelArn']
   ```

1. Berikan waktu untuk pembuatan selesai. Anda dapat memeriksa statusnya dengan cuplikan kode berikut. Anda dapat memberikan nama Throughput yang Disediakan atau ARN yang dikembalikan dari respons sebagai. [CreateProvisionedModelThroughput](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_CreateProvisionedModelThroughput.html)`provisionedModelId`

   ```
   bedrock.get_provisioned_model_throughput(provisionedModelId=provisioned_model_name)
   ```

1. Jalankan inferensi dengan model penyediaan Anda yang diperbarui dengan perintah berikut dan gunakan ARN dari model yang disediakan sebagai. `modelId`

   ```
   import json
   import logging
   import boto3
   
   from botocore.exceptions import ClientError
   
   
   class ImageError(Exception):
       "Custom exception for errors returned by the model"
   
       def __init__(self, message):
           self.message = message
   
   
   logger = logging.getLogger(__name__)
   logging.basicConfig(level=logging.INFO)
   
   
   def generate_text(model_id, body):
       """
       Generate text using your provisioned custom model.
       Args:
           model_id (str): The model ID to use.
           body (str) : The request body to use.
       Returns:
           response (json): The response from the model.
       """
   
       logger.info(
           "Generating text with your provisioned custom model %s", model_id)
   
       brt = boto3.client(service_name='bedrock-runtime')
   
       accept = "application/json"
       content_type = "application/json"
   
       response = brt.invoke_model(
           body=body, modelId=model_id, accept=accept, contentType=content_type
       )
       response_body = json.loads(response.get("body").read())
   
       finish_reason = response_body.get("error")
   
       if finish_reason is not None:
           raise ImageError(f"Text generation error. Error is {finish_reason}")
   
       logger.info(
           "Successfully generated text with provisioned custom model %s", model_id)
   
       return response_body
   
   
   def main():
       """
       Entrypoint for example.
       """
       try:
           logging.basicConfig(level=logging.INFO,
                               format="%(levelname)s: %(message)s")
   
           model_id = provisioned-model-arn
   
           body = json.dumps({
               "inputText": "what isAWS?"
           })
   
           response_body = generate_text(model_id, body)
           print(f"Input token count: {response_body['inputTextTokenCount']}")
   
           for result in response_body['results']:
               print(f"Token count: {result['tokenCount']}")
               print(f"Output text: {result['outputText']}")
               print(f"Completion reason: {result['completionReason']}")
   
       except ClientError as err:
           message = err.response["Error"]["Message"]
           logger.error("A client error occurred: %s", message)
           print("A client error occured: " +
                 format(message))
       except ImageError as err:
           logger.error(err.message)
           print(err.message)
   
       else:
           print(
               f"Finished generating text with your provisioned custom model {model_id}.")
   
   
   if __name__ == "__main__":
       main()
   ```

1. Hapus Throughput yang Disediakan dengan cuplikan kode berikut. Anda tidak akan lagi dikenakan biaya untuk Throughput yang Disediakan.

   ```
   bedrock.delete_provisioned_model_throughput(provisionedModelId=provisioned_model_name)
   ```

------