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

Uso de Aurora Serverless con AWS AppSync

AWS AppSync proporciona una fuente de datos para ejecutar SQL comandos en los clústeres de Amazon Aurora Serverless que se han habilitado con un DataAPI. Puedes usar AppSync resolutores para ejecutar SQL sentencias contra los datos API con consultas, mutaciones y suscripciones de GraphQL.

Crear un clúster

Antes de añadir una fuente de RDS datos, primero AppSync debe habilitar un clúster de Data API on a Aurora Serverless y configurar un secreto mediante AWS Secrets Manager. Puede crear primero un clúster Aurora Serverless 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á una ARN para el clúster.

Crea un secreto a través de la AWS Secrets Manager consola o también a través de un archivo de entrada como el siguiente utilizando las USERNAME teclas y COMPLEX _ PASSWORD del paso anterior: CLI


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

Pase esto como parámetro a AWS CLI:


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

Esto devolverá un formulario ARN para el secreto.

Anote el clúster y el secreto ARN de Aurora Serverless para usarlos posteriormente en la AppSync consola al crear una fuente de datos.

Habilite los datos API

Puede habilitar los datos API en su clúster siguiendo las instrucciones de la RDS documentación. Los datos API deben estar habilitados antes de añadirlos como fuente AppSync de datos.

Creación de una base de datos y tabla

Una vez que haya habilitado sus datos, API puede asegurarse de que funcionan con el aws rds-data execute-statement comando de AWS CLI. Esto garantizará que el clúster Aurora Serverless esté configurado correctamente antes de añadirlo al suyo AppSync API. Primero cree una base de datos llamada TESTDBcon el --sql parámetro siguiente:


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 ha funcionado sin problemas, puede continuar y agregar el clúster como fuente de datos en su AppSync API.

Esquema de GraphQL

Ahora que sus datos API sin servidor de Aurora están funcionando con una tabla, crearemos un esquema de GraphQL y adjuntaremos resolutores para realizar mutaciones y suscripciones. Cree una nueva API en la AWS AppSync consola, vaya a la página del esquema e introduzca 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 creó en el último paso, así como el clúster en el ARN que la creó. Para el rol, puede AppSync crear un nuevo rol o crear 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 Aurora Serverless y el segundo es su AWS Secrets Manager ARN. Deberá proporcionar la configuración de la fuente BOTHARNsde AppSync datos antes de hacer clic en Crear.

Configuración de solucionadores

Ahora que tenemos un esquema GraphQL válido y una fuente de RDS datos, podemos adjuntar resolutores a los campos de GraphQL de nuestro esquema. Las nuestras API ofrecerán las siguientes capacidades:

crea una mascota mediante la mutación. createPetcampo
actualiza una mascota mediante la mutación. updatePetcampo
eliminar una mascota mediante la mutación. deletePetcampo
consigue una sola mascota a través de la consulta. getPetcampo
enumere todas las mascotas a través de la consulta. listPetscampo
publique las mascotas en un rango de precios a través de la consulta. listPetsByPriceRangecampo

Mutación. createPet

En el editor de esquemas de la AWS AppSync consola, en el lado derecho, selecciona Attach Resolver forcreatePet(input: CreatePetInput!): Pet. Elija el origen de los datos de RDS. En la sección 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 SQL sentencias se ejecutarán secuencialmente, según el orden de la matriz de sentencias. 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.