As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Programe seu aplicativo Managed Service for Apache Flink Python
<a name="how-python-programming"></a>

Você codifica seu aplicativo Python para o Managed Service for Apache Flink usando a API Apache Flink Python Table. O mecanismo Apache Flink traduz as instruções da Python Table API (em execução na Python VM) em instruções da Java Table API (executadas na Java VM). 

Para isso, você usa a Python Table API da seguinte maneira:
+ Crie uma referência para o `StreamTableEnvironment`.
+ Crie `table` objetos a partir dos dados de streaming de origem executando consultas na `StreamTableEnvironment` referência.
+ Execute consultas em seus `table` objetos para criar tabelas de saída.
+ Grave suas tabelas de saída em seus destinos usando um`StatementSet`.

Para começar a usar a Python Table API no Managed Service for Apache Flink, consulte. [Conceitos básicos do Amazon Managed Service for Apache Flink para Python](gs-python.md)

## Leia e grave dados de transmissão
<a name="how-python-programming-readwrite"></a>

Para ler e gravar dados de streaming, você executa consultas SQL no ambiente de tabela.

### Criar uma tabela
<a name="how-python-programming-readwrite-createtable"></a>

O exemplo de código a seguir demonstra uma função definida pelo usuário que cria uma consulta SQL. A consulta SQL cria uma tabela que interage com um stream do Kinesis:

```
def create_table(table_name, stream_name, region, stream_initpos):
   return """ CREATE TABLE {0} (
                `record_id` VARCHAR(64) NOT NULL,
                `event_time` BIGINT NOT NULL,
                `record_number` BIGINT NOT NULL,
                `num_retries` BIGINT NOT NULL,
                `verified` BOOLEAN NOT NULL
              )
              PARTITIONED BY (record_id)
              WITH (
                'connector' = 'kinesis',
                'stream' = '{1}',
                'aws.region' = '{2}',
                'scan.stream.initpos' = '{3}',
                'sink.partitioner-field-delimiter' = ';',
                'sink.producer.collection-max-count' = '100',
                'format' = 'json',
                'json.timestamp-format.standard' = 'ISO-8601'
              ) """.format(table_name, stream_name, region, stream_initpos)
```

### Leia dados de transmissão
<a name="how-python-programming-readwrite-read"></a>

O exemplo de código a seguir demonstra como usar a consulta `CreateTable` SQL anterior em uma referência de ambiente de tabela para ler dados:

```
   table_env.execute_sql(create_table(input_table, input_stream, input_region, stream_initpos))
```

### Grave dados de transmissão
<a name="how-python-programming-readwrite-write"></a>

O exemplo de código a seguir demonstra como usar a consulta SQL do `CreateTable` exemplo para criar uma referência de tabela de saída e como usar a `StatementSet` para interagir com as tabelas para escrever dados em um stream do Kinesis de destino:

```
   table_result = table_env.execute_sql("INSERT INTO {0} SELECT * FROM {1}"
                       .format(output_table_name, input_table_name))
```

## Leia propriedades de runtime
<a name="how-python-programming-properties"></a>

Você pode usar propriedades de runtime para configurar seu aplicativo sem alterar o código do aplicativo.

Você especifica as propriedades do aplicativo da mesma forma que com um Managed Service for Apache Flink para aplicativo Java. É possível especificar as propriedades do runtime das seguintes maneiras:
+ Usando a [CreateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_CreateApplication.html)ação.
+ Usando a [UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)ação.
+ Usar seu aplicativo usando o console.

Você recupera as propriedades do aplicativo no código lendo um arquivo json chamado `application_properties.json` aquele criado pelo runtime do Managed Service for Apache Flink.

O exemplo de código a seguir demonstra a leitura das propriedades do aplicativo a partir do arquivo `application_properties.json`:

```
file_path = '/etc/flink/application_properties.json'
   if os.path.isfile(file_path):
       with open(file_path, 'r') as file:
           contents = file.read()
           properties = json.loads(contents)
```

O exemplo de código de função definido pelo usuário a seguir demonstra a leitura de um grupo de propriedades do objeto de propriedades do aplicativo: recupera:

```
def property_map(properties, property_group_id):
   for prop in props:
       if prop["PropertyGroupId"] == property_group_id:
           return prop["PropertyMap"]
```

O exemplo de código a seguir demonstra a leitura de uma propriedade chamada INPUT\_STREAM\_KEY de um grupo de propriedades que o exemplo anterior retorna:

```
input_stream = input_property_map[INPUT_STREAM_KEY]
```

## Crie o pacote de código do seu aplicativo
<a name="how-python-programming-package"></a>

Depois de criar seu aplicativo Python, você empacota seu arquivo de código e dependências em um arquivo zip.

Seu arquivo zip deve conter um script python com um método `main` e, opcionalmente, pode conter o seguinte:
+ Arquivos de código Python adicionais
+ User-defined Código Java em arquivos JAR
+ Bibliotecas Java em arquivos JAR

**nota**  
O arquivo zip do aplicativo deve conter todas as dependências do aplicativo. Você não pode referenciar bibliotecas de outras fontes para seu aplicativo.