Crear un clúster Habilitar la API de datos Creación de una base de datos y tabla Esquema de GraphQL Configuración de solucionadores Ejecutar mutaciones Ejecutar consultas Saneamiento de la entrada

Tutorial: Aurora sin servidor

AWS AppSync proporciona un origen de datos para ejecutar comandos SQL con respecto a clústeres de Amazon Aurora sin servidor que se han habilitado con una API de datos. Puede utilizar los solucionadores de AppSync para ejecutar instrucciones de SQL con respecto a la API de datos con consultas, mutaciones y suscripciones de GraphQL.

Crear un clúster

Antes de añadir un origen de datos de RDS a AppSync primero debe habilitar una API de datos en un clúster de Aurora sin servidor y configurar un secreto con AWS Secrets Manager. Puede crear un clúster de Aurora sin servidor primero con AWS CLI:


aws rds create-db-cluster --db-cluster-identifier http-endpoint-test  --master-username USERNAME \
--master-user-password COMPLEX_PASSWORD --engine aurora --engine-mode serverless \
--region us-east-1

Esto devolverá un ARN para el clúster.

Cree un secreto a través de la consola de AWS Secrets Manager o también a través de la interfaz de línea de comandos (CLI) con un archivo de entrada como el siguiente utilizando los valores de USERNAME y COMPLEX_PASSWORD del paso anterior:


{
    "username": "USERNAME",
    "password": "COMPLEX_PASSWORD"
}

Transfiera esto como parámetro a la AWS CLI:


aws secretsmanager create-secret --name HttpRDSSecret --secret-string file://creds.json --region us-east-1

Esto devolverá un ARN para el secreto.

Anote el ARN de su clúster de Aurora Serverless y secreto para su uso posterior en la consola de AppSync a la hora de crear un origen de datos.

Habilitar la API de datos

Puede habilitar la API de datos en el clúster siguiendo las instrucciones de la documentación de RDS. La API de datos debe estar habilitada antes de añadirse como un origen de datos de AppSync.

Creación de una base de datos y tabla

Una vez que tenga habilitada su API de datos, puede asegurarse de que funciona con el comando aws rds-data execute-statement de la AWS CLI. Esto garantizará que el clúster de Aurora sin servidor esté configurado correctamente antes de añadirlo a la API de AppSync. En primer lugar, cree una base de datos denominada TESTDB con el parámetro --sql del siguiente modo:


aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789000:cluster:http-endpoint-test" \
--schema "mysql"  --secret-arn "arn:aws:secretsmanager:us-east-1:123456789000:secret:testHttp2-AmNvc1"  \
--region us-east-1 --sql "create DATABASE TESTDB"

Si esto se ejecuta sin errores, añada una tabla con el comando de creación de tablas:


aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789000:cluster:http-endpoint-test" \
 --schema "mysql"  --secret-arn "arn:aws:secretsmanager:us-east-1:123456789000:secret:testHttp2-AmNvc1" \
 --region us-east-1 \
 --sql "create table Pets(id varchar(200), type varchar(200), price float)" --database "TESTDB"

Si todo se ha ejecutado sin problemas puede avanzar para añadir el clúster como origen de datos en la API de AppSync.

Esquema de GraphQL

Ahora que su API de datos de Aurora Serverless está en marcha con una tabla, vamos a crear un esquema GraphQL y asociar los solucionadores para realizar mutaciones y suscripciones. Cree una nueva API en la consola de AWS AppSync, vaya a la página Esquema y escriba lo siguiente:


type Mutation {
    createPet(input: CreatePetInput!): Pet
    updatePet(input: UpdatePetInput!): Pet
    deletePet(input: DeletePetInput!): Pet
}

input CreatePetInput {
    type: PetType
    price: Float!
}

input UpdatePetInput {
id: ID!
    type: PetType
    price: Float!
}

input DeletePetInput {
    id: ID!
}

type Pet {
    id: ID!
    type: PetType
    price: Float
}

enum PetType {
    dog
    cat
    fish
    bird
    gecko
}

type Query {
    getPet(id: ID!): Pet
    listPets: [Pet]
    listPetsByPriceRange(min: Float, max: Float): [Pet]
}

schema {
    query: Query
    mutation: Mutation
}

Guarde su esquema y vaya a la página Data Sources (Orígenes de datos) y cree un nuevo origen de datos. Seleccione la Relational database (Base de datos relacional) para el tipo de origen de datos y proporcione un nombre fácil de recordar. Utilice el nombre de la base de datos que ha creado en el último paso, así como el Cluster ARN (ARN del clúster) en el que lo creó. Para el Role (Rol) puede permitir que AppSync cree un rol nuevo o cree uno con una política similar a la siguiente:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "rds-data:DeleteItems",
                "rds-data:ExecuteSql",
                "rds-data:ExecuteStatement",
                "rds-data:GetItems",
                "rds-data:InsertItems",
                "rds-data:UpdateItems"
            ],
            "Resource": [
                "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster",
                "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue"
            ],
            "Resource": [
                "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret",
                "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret:*"
            ]
        }
    ]
}

Tenga en cuenta que hay dos Statements (Instrucciones) en esta política a las que está concediendo acceso de rol. El primer Recurso es su clúster de Aurora sin servidor y el segundo es su ARN de AWS Secrets Manager. Tendrá que proporcionar AMBOS ARN en la configuración del origen de datos de AppSync antes de hacer clic en Create (Crear).

Configuración de solucionadores

Ahora que tenemos un esquema de GraphQL válido y un origen de datos de RDS, podemos asociar los solucionadores a los campos de GraphQL en el esquema. Nuestra API ofrecerá las siguientes capacidades:

crear una mascota a través del campo Mutation.createPet
actualizar una mascota a través del campo Mutation.updatePet
eliminar una mascota a través del campo Mutation.deletePet
obtener una mascota única a través del campo Query.getPet
enumerar todas las mascotas a través del campo Query.listPets
enumerar las mascotas en un rango de precios a través del campo Query.listPetsByPriceRange

Mutation.createPet

En el editor de esquemas de la consola de AWS AppSync, elija a la derecha Asociar solucionador para createPet(input: CreatePetInput!): Pet. Elija el origen de los datos de RDS. En la sección request mapping template (plantilla de mapeo de solicitudes), añada la siguiente plantilla:


#set($id=$utils.autoId())
{
"version": "2018-05-29",
    "statements": [
        "insert into Pets VALUES (:ID, :TYPE, :PRICE)",
        "select * from Pets WHERE id = :ID"
    ],
    "variableMap": {
        ":ID": "$ctx.args.input.id",
        ":TYPE": $util.toJson($ctx.args.input.type),
        ":PRICE": $util.toJson($ctx.args.input.price)
    }
}

Las instrucciones SQL se ejecutarán de forma secuencial, en función del orden de la matriz statements (instrucciones). Los resultados volverán en el mismo orden. Dado que se trata de una mutación, ejecutamos una instrucción select (selección) después de insert (insertar) para recuperar los valores comprometidos para rellenar la plantilla de mapeo de respuesta de GraphQL.