Introspecção do RDS - AWS AppSync
Usar o recurso de introspecção (console)Usar o recurso de introspecção (API)

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á.

Introspecção do RDS

O AWS AppSync facilita a criação de APIs por meio de bancos de dados relacionais. O utilitário de introspecção pode descobrir modelos por meio de tabelas de banco de dados e propor tipos de GraphQL. O assistente de API de criação do console do AWS AppSync pode gerar instantaneamente uma API por meio de um banco de dados Aurora MySQL ou PostgreSQL. Ele cria automaticamente tipos e resolvedores de JavaScript para ler e gravar dados.

O AWS AppSync oferece integração direta com bancos de dados Amazon Aurora por meio da API de dados do Amazon RDS. Em vez de exigir uma conexão persistente com o banco de dados, a API de dados do Amazon RDS oferece um endpoint HTTP seguro com o qual o AWS AppSync se conecta para executar declarações SQL. É possível usá-lo para criar uma API de banco de dados relacional para as workloads MySQL e PostgreSQL no Aurora.

A criação de uma API para o banco de dados relacional com o AWS AppSync tem várias vantagens:

  • O banco de dados não é diretamente exposto aos clientes, separando o ponto de acesso do próprio banco de dados.

  • É possível criar APIs com propósito especifico, adaptadas a diferentes aplicações, eliminando a necessidade de lógica de negócios personalizada nos front-ends. Isso se alinha ao padrão Backend-For-Frontend (BFF).

  • A autorização e o controle de acesso podem ser implementados na camada do AWS AppSync usando vários modos de autorização para controlar o acesso. Nenhum recurso computacional adicional é necessário para se conectar ao banco de dados, como hospedar um servidor web ou fazer conexões por proxy.

  • Recursos em tempo real podem ser adicionados por meio de assinaturas, com mutações de dados feitas por meio do AppSync enviadas automaticamente aos clientes conectados.

  • Os clientes podem se conectar à API via HTTPS usando portas comuns, como 443.

O AWS AppSync facilita a criação de APIs por meio de bancos de dados relacionais. O utilitário de introspecção pode descobrir modelos por meio de tabelas de banco de dados e propor tipos de GraphQL. O assistente de API de criação do console do AWS AppSync pode gerar instantaneamente uma API por meio de um banco de dados Aurora MySQL ou PostgreSQL. Ele cria automaticamente tipos e resolvedores de JavaScript para ler e gravar dados.

O AWS AppSync oferece utilitários JavaScript integrados para simplificar a gravação de declarações SQL em resolvedores. É possível usar os modelos de tag sql do AWS AppSync para declarações estáticas com valores dinâmicos ou os utilitários do módulo do rds para criar declarações de forma programática. Consulte as fontes de dados da referência de funções de resolvedores do RDS e módulos integrados para obter mais informações.

Usar o recurso de introspecção (console)

Para ver um tutorial detalhado e um guia de introdução, consulte Tutorial: Aurora PostgreSQL Serverless with Data API.

O console do AWS AppSync permite criar uma API do GraphQL do AWS AppSync por meio do banco de dados Aurora existente configurado com a API de dados em apenas alguns minutos. Isso gera rapidamente um esquema operacional com base na configuração do banco de dados. É possível usar a API no estado em que se encontra ou desenvolvê-la para adicionar recursos.

  1. Faça login no AWS Management Console e abra o Console do AppSync.

    1. No Painel, escolha Criar API.

  2. Em Opções de API, selecione APIs do GraphQL, Iniciar com um cluster do Amazon Aurora e, depois, Próximo.

    1. Insira um Nome da API. Isso será usado como um identificador para a API no console.

    2. Para obter detalhes de contato, você pode inserir um ponto de contato para identificar um gerente para a API. Esse é um campo opcional.

    3. Em Configuração da API privada, é possível habilitar os atributos da API privada. Uma API privada só pode ser acessada de um endpoint da VPC (VPCE) configurado. Para mais informações, consulte Private APIs.

      Não recomendamos habilitar esse atributo para este exemplo. Após analisar suas entradas, selecione Próximo.

  3. Na página Banco de dados, escolha Selecionar banco de dados.

    1. É necessário escolher o banco de dados no cluster. A primeira etapa é selecionar a região na qual o cluster existe.

    2. Selecione o Cluster do Aurora na lista suspensa. Observe que é necessário ter criado e habilitado uma API de dados correspondente antes de usar o recurso.

    3. Depois, é necessário adicionar as credenciais do banco de dados ao serviço. Isso é feito principalmente com o uso do AWS Secrets Manager. Selecione a região onde existe o segredo. Para obter mais informações sobre como recuperar informações de segredos, consulte Find secrets ou Retrieve secrets.

    4. Adicione o segredo da lista suspensa. Observe que o usuário deve ter permissões de leitura para o banco de dados.

  4. Escolha Importar.

    O AWS AppSync começará a realizar a introspecção do banco de dados, descobrindo tabelas, colunas, chaves primárias e índices. Ele confere se as tabelas descobertas podem ser compatíveis com uma API do GraphQL. Observe que, para oferecer compatibilidade com a criação de linhas, as tabelas precisam de uma chave primária, que pode usar várias colunas. O AWS AppSync associa colunas da tabela a campos de texto da seguinte forma:

    Tipo de dados Tipo de campo
    VARCHAR String
    CHAR String
    BINARY String
    VARBINARY String
    TINYBLOB String
    TINYTEXT String
    TEXT String
    BLOB String
    MEDIUMTEXT String
    MEDIUMBLOB String
    LONGTEXT String
    LONGBLOB String
    BOOL Boolean
    BOOLEAN Boolean
    BIT Int
    TINYINT Int
    SMALLINT Int
    MEDIUMINT Int
    INT Int
    INTEGER Int
    BIGINT Int
    YEAR Int
    FLOAT Float
    DOUBLE Float
    DECIMAL Float
    DEC Float
    NUMERIC Float
    DATE AWSDate
    TIMESTAMP String
    DATETIME String
    TIME AWSTime
    JSON AWSJson
    ENUM ENUM

  5. Quando a descoberta da tabela for concluída, a seção Banco de dados será preenchida com as informações. Na nova seção Tabelas do banco de dados, os dados da tabela podem já estar preenchidos e convertidos em um tipo para o esquema. Se você não vê alguns dos dados necessários, pode verificá-los escolhendo Adicionar tabelas, clicando nas caixas de seleção desses tipos no modal exibido e escolhendo Adicionar.

    Para remover um tipo da seção Tabelas do banco de dados, clique na caixa de seleção ao lado do tipo a ser removido e selecione Remover. Os tipos removidos serão colocados no modal Adicionar tabelas se quiser adicioná-los novamente mais tarde.

    Observe que o AWS AppSync usa os nomes das tabelas como nomes de tipo, mas é possível renomeá-los, por exemplo, alterando o nome de uma tabela no plural, como filmes, para o nome do tipo Filme. Para renomear um tipo na seção Tabelas do banco de dados, clique na caixa de seleção do tipo a ser renomeado e, depois, clique no ícone de lápis na coluna Nome do tipo.

    Para visualizar o conteúdo do esquema com base nas seleções, selecione Visualizar esquema. Observe que esse esquema não pode estar vazio. Será necessário ter, pelo menos, uma tabela convertida em um tipo. Além disso, esse esquema não pode exceder 1 MB.

    1. Em Perfil de serviço, decida se deseja criar um perfil de serviço especificamente para essa importação ou usar um perfil existente.

  6. Escolha Next (Próximo).

  7. Depois, decida se deseja criar uma API somente leitura (somente consultas) ou uma API para leitura e gravação de dados (com consultas e mutações). O último também aceita assinaturas em tempo real acionadas por mutações.

  8. Escolha Next (Próximo).

  9. Revise as escolhas e, depois, selecione Criar API. O AWS AppSync criará a API e anexará resolvedores a consultas e mutações. A API gerada é totalmente funcional e pode ser estendida conforme necessário.

Usar o recurso de introspecção (API)

É possível usar a API de introspecção StartDataSourceIntrospection para descobrir modelos no banco de dados de forma programática. Para obter mais detalhes sobre o comando, consulte Usar a API StartDataSourceIntrospection.

Para usar StartDataSourceIntrospection, forneça o nome do recurso da Amazon (ARN) do cluster do Aurora, o nome do banco de dados e o ARN do segredo do AWS Secrets Manager. O comando inicia o processo de introspecção. É possível recuperar os resultados com o comando GetDataSourceIntrospection. É possível especificar se o comando deve exibir a string SDL (linguagem de definição de armazenamento) para os modelos descobertos. Ela é útil para gerar uma definição de esquema SDL diretamente pelos modelos descobertos.

Por exemplo, se você tiver a seguinte declaração de linguagem de definição de dados (DDL) para uma tabela Todos simples:

create table if not exists public.todos  
(  
id serial constraint todos_pk primary key,  
description text,  
due timestamp,  
"createdAt" timestamp default now()  
);

Você deve começar a introspecção com o seguinte:

aws appsync start-data-source-introspection \ 
  --rds-data-api-config resourceArn=<cluster-arn>,secretArn=<secret-arn>,databaseName=database

Depois, use o comando GetDataSourceIntrospection para recuperar o resultado.

aws appsync get-data-source-introspection \
  --introspection-id a1234567-8910-abcd-efgh-identifier \
  --include-models-sdl

Ele exibirá o resultado a seguir.

{
    "introspectionId": "a1234567-8910-abcd-efgh-identifier",
    "introspectionStatus": "SUCCESS",
    "introspectionStatusDetail": null,
    "introspectionResult": {
        "models": [
            {
                "name": "todos",
                "fields": [
                    {
                        "name": "description",
                        "type": {
                            "kind": "Scalar",
                            "name": "String",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "due",
                        "type": {
                            "kind": "Scalar",
                            "name": "AWSDateTime",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "id",
                        "type": {
                            "kind": "NonNull",
                            "name": null,
                            "type": {
                                "kind": "Scalar",
                                "name": "Int",
                                "type": null,
                                "values": null
                            },
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "createdAt",
                        "type": {
                            "kind": "Scalar",
                            "name": "AWSDateTime",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    }
                ],
                "primaryKey": {
                    "name": "PRIMARY_KEY",
                    "fields": [
                        "id"
                    ]
                },
                "indexes": [],
                "sdl": "type todos\n{\ndescription: String\n\ndue: AWSDateTime\n\nid: Int!\n\ncreatedAt: AW
SDateTime\n}\n"
            }
        ],
        "nextToken": null
    }
}