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

# Memanggil AWS Glue APIs dengan Python
<a name="aws-glue-programming-python-calling"></a>

Perhatikan bahwa sumber daya Boto 3 belum APIs tersedia untukAWS Glue. Saat ini, hanya klien Boto 3 yang APIs dapat digunakan.

## AWS GlueNama API dalam Python
<a name="aws-glue-programming-python-calling-names"></a>

AWS Nama Glue API di Java dan bahasa pemrograman lainnya umumnya CamelCased. Namun, ketika dipanggil dari Python, nama-nama generik ini diubah menjadi huruf kecil, di mana bagian-bagian dari nama tersebut dipisahkan oleh karakter garis bawah untuk membuatnya menjadi lebih "Pythonic". Dalam dokumentasi [AWS Glue API](aws-glue-api.md) referensi, nama-nama Pythonic ini tercantum dalam tanda kurung setelah nama generik. CamelCased 

Namun, meskipun nama AWS Glue API itu sendiri diubah menjadi huruf kecil, nama parameternya tetap dikapitalisasi. Penting untuk mengingat ini, karena parameter harus diteruskan dengan nama saat memanggil AWS Glue APIs, seperti yang dijelaskan di bagian berikut.

## Melewati dan mengakses parameter Python di AWS Glue
<a name="aws-glue-programming-python-calling-parameters"></a>

Dalam panggilan Python ke AWS Glue APIs, yang terbaik adalah meneruskan parameter secara eksplisit berdasarkan nama. Contoh:

```
job = glue.create_job(Name='sample', Role='Glue_DefaultRole',
                      Command={'Name': 'glueetl',
                               'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'})
```

Sangat membantu untuk memahami bahwa Python membuat kamus name/value tupel yang Anda tentukan sebagai argumen untuk skrip ETL dalam atau. [Struktur Job](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) [JobRun struktur](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-JobRun) Boto 3 kemudian meneruskannya ke AWS Glue dalam format JSON melalui panggilan REST API. Ini berarti bahwa Anda tidak dapat mengandalkan urutan argumen ketika Anda mengaksesnya dalam skrip Anda.

Misalnya, anggaplah Anda memulai `JobRun` dalam fungsi penangan Python Lambda, dan Anda ingin menentukan beberapa parameter. Kode Anda mungkin terlihat seperti yang berikut ini:

```
from datetime import datetime, timedelta

client = boto3.client('glue')

def lambda_handler(event, context):
  last_hour_date_time = datetime.now() - timedelta(hours = 1)
  day_partition_value = last_hour_date_time.strftime("%Y-%m-%d")
  hour_partition_value = last_hour_date_time.strftime("%-H")

  response = client.start_job_run(
               JobName = 'my_test_Job',
               Arguments = {
                 '--day_partition_key':   'partition_0',
                 '--hour_partition_key':  'partition_1',
                 '--day_partition_value':  day_partition_value,
                 '--hour_partition_value': hour_partition_value } )
```

Untuk mengakses parameter ini dengan andal dalam skrip ETL Anda, tentukan dengan nama menggunakan AWS Glue `getResolvedOptions` fungsi dan kemudian akses dari kamus yang dihasilkan:

```
import sys
from awsglue.utils import getResolvedOptions

args = getResolvedOptions(sys.argv,
                          ['JOB_NAME',
                           'day_partition_key',
                           'hour_partition_key',
                           'day_partition_value',
                           'hour_partition_value'])
print "The day partition key is: ", args['day_partition_key']
print "and the day partition value is: ", args['day_partition_value']
```

Jika Anda ingin meneruskan argumen yang merupakan string JSON bersarang, untuk mempertahankan nilai parameter saat diteruskan ke pekerjaan AWS Glue ETL Anda, Anda harus menyandikan string parameter sebelum memulai pekerjaan, dan kemudian memecahkan kode string parameter sebelum mereferensikannya skrip pekerjaan Anda. Sebagai contoh, pertimbangkan string argumen berikut:

```
glue_client.start_job_run(JobName = "gluejobname", Arguments={
"--my_curly_braces_string": '{"a": {"b": {"c": [{"d": {"e": 42}}]}}}'
})
```

Untuk memberikan parameter ini dengan benar, Anda harus mengkodekan argumen sebagai string dengan encoding Base64.

```
import base64
...
sample_string='{"a": {"b": {"c": [{"d": {"e": 42}}]}}}'
sample_string_bytes = sample_string.encode("ascii")

base64_bytes = base64.b64encode(sample_string_bytes) 
base64_string = base64_bytes.decode("ascii") 
...
glue_client.start_job_run(JobName = "gluejobname", Arguments={
"--my_curly_braces_string": base64_bytes})
...
sample_string_bytes = base64.b64decode(base64_bytes) 
sample_string = sample_string_bytes.decode("ascii") 
print(f"Decoded string: {sample_string}") 
...
```

## Contoh: Membuat dan menjalankan pekerjaan
<a name="aws-glue-programming-python-calling-example"></a>

Contoh berikut menunjukkan bagaimana memanggil AWS Glue APIs menggunakan Python, untuk membuat dan menjalankan pekerjaan ETL.

**Membuat dan menjalankan sebuah tugas**

1. Buat instance AWS Glue klien:

   ```
   import boto3
   glue = boto3.client(service_name='glue', region_name='us-east-1',
                 endpoint_url='https://glue.us-east-1.amazonaws.com')
   ```

1. Membuat sebuah tugas. Anda harus menggunakan `glueetl` sebagai nama untuk perintah ETL, seperti yang ditunjukkan dalam kode berikut:

   ```
   myJob = glue.create_job(Name='sample', Role='Glue_DefaultRole',
                             Command={'Name': 'glueetl',
                                      'ScriptLocation': 's3://my_script_bucket/scripts/my_etl_script.py'})
   ```

1. Mulai eksekusi baru pada tugas Anda yang Anda buat di langkah sebelumnya:

   ```
   myNewJobRun = glue.start_job_run(JobName=myJob['Name'])
   ```

1. Ambil status tugas:

   ```
   status = glue.get_job_run(JobName=myJob['Name'], RunId=myNewJobRun['JobRunId'])
   ```

1. Mencetak status eksekusi tugas saat ini:

   ```
   print(status['JobRun']['JobRunState'])
   ```