[PYTHON] Hit AppSync certifié Cognito par derrière avec la certification IAM

Hit AppSync certifié Cognito par derrière avec la certification IAM

introduction

Auparavant, j'ai publié "Utiliser AppSync sur le frontend et le backend" comme article pratique sur l'application Web sans serveur. Ici, bien entendu, la "clé API" a été utilisée comme mode d'authentification. L'authentification avec cette clé API est bonne pour les débutants à l'utiliser en premier ou comme simple prototype, mais compte tenu de la sécurité et du problème de mise à jour avec une date d'expiration maximale de 365 jours, D'autres modes d'authentification doivent être adoptés si possible. Vous pouvez voir la clé ... J'oublierai certainement de mettre à jour la clé après 365 jours.

Type de mode d'authentification AppSync

En plus de la clé API, AppSync prend en charge les modes d'authentification suivants.

• AWS Identity and Access Management (IAM)
• Pool d'utilisateurs Amazon Cognito
• OpenID Connect

** Qu'est-ce que l'IAM ** C'est un mécanisme pour contrôler la plage et la méthode d'accès pour accéder aux ressources AWS.

** Qu'est-ce que le pool d'utilisateurs Cognito ** Il s'agit d'un mécanisme de gestion des utilisateurs de l'application (état d'inscription et de connexion).

** Qu'est-ce qu'OpenID Connect ** Je ne le connais pas car je ne l'ai jamais utilisé. (Semblable à Cognito, vous avez l'impression de vous connecter et de vous authentifier à l'aide du jeton émis?)

Utilisez une combinaison de plusieurs modes d'authentification

AppSync a pris en charge plusieurs modes d'authentification en mai 2019. https://aws.amazon.com/jp/about-aws/whats-new/2019/05/aws-appsync-now-supports-configuring-multiple-authorization-type/

Cela permet au frontal (côté client) de s'authentifier auprès de Cognito et au backend (côté serveur) avec IAM.

Ajouter l'authentification IAM et frapper avec Lambda (Python)

En utilisant Amplify, il est devenu possible de réaliser rapidement la construction d'AppSync avec l'authentification Cognito et la mise en œuvre de son utilisation depuis le front-end (application Web).

À partir de là dans cet article, Ajout d'IAM en tant que fournisseur d'authentification à utiliser sur le backend, Je voudrais écrire sur la frappe (appelant l'API) de Lambda (Python).

Ajouter IAM à des fournisseurs d'authentification supplémentaires

AWS Console> AWS AppSync> Sélectionnez l'API souhaitée> Paramètres Il y a un élément appelé "Fournisseur d'authentification supplémentaire" en bas, alors appuyez sur le bouton Nouveau. Sélectionnez «AWS Identify and Access Management (IAM)» dans la zone de liste déroulante du mode d'authentification sur l'écran contextuel «Définir un fournisseur d'authentification supplémentaire» et appuyez sur le bouton «Envoyer». Confirmez que «AWS Identify and Access Management (IAM)» est ajouté à «Additional Authentication Provider» dans les paramètres, puis appuyez sur le bouton «Enregistrer» en bas. (* N'oubliez pas!)

Spécifiez le mode d'authentification dans le schéma

Si vous souhaitez utiliser plusieurs modes d'authentification, vous devez ajouter au schéma. Vous pouvez spécifier en détail ce qui peut être fait dans quel mode d'authentification pour chaque type de racine, comme la requête, la mutation, l'abonnement et les champs de fonction définis par l'utilisateur et les types d'objet qu'il contient. (* Ne peut pas être spécifié pour l'entrée (type d'entrée).)

Par défaut, rien n'est spécifié, ce qui signifie que seul le mode d'authentification principal est autorisé et que le mode d'authentification ajouté n'est pas autorisé. Vous pouvez spécifier le mode d'authentification en faisant les marquages suivants.

• @aws_api_key
  Spécifie que le champ est approuvé par API_KEY.
• @aws_iam
  Spécifie que le champ est approuvé par AWS_IAM.
• @aws_oidc
  Spécifie que le champ est approuvé avec OPENID_CONNECT.
• @aws_cognito_user_pools
  Indique que le champ est approuvé par AMAZON_COGNITO_USER_POOLS Ensemble.

Consultez ce guide du développeur pour plus de détails. (Plutôt, tout est écrit ici) https://docs.aws.amazon.com/ja_jp/appsync/latest/devguide/appsync-dg%20.pdf

AWS Console> AWS AppSync> Sélectionnez l'API souhaitée> Schéma Après avoir édité le schéma graphql ici, cliquez sur le bouton "Enregistrer le schéma".

Voici quelques exemples de schémas pré-édités (Before.graphql) et post-édités (After.graphql).

Before.graphql

type Mutation {
	createSampleAppsyncTable(input: CreateSampleAppsyncTableInput!): SampleAppsyncTable
	updateSampleAppsyncTable(input: UpdateSampleAppsyncTableInput!): SampleAppsyncTable
	deleteSampleAppsyncTable(input: DeleteSampleAppsyncTableInput!): SampleAppsyncTable
}

type Query {
	getSampleAppsyncTable(group: String!, path: String!): SampleAppsyncTable
	listSampleAppsyncTables(filter: TableSampleAppsyncTableFilterInput, limit: Int, nextToken: String): SampleAppsyncTableConnection
}

type SampleAppsyncTable {
	group: String!
	path: String!
}

After.graphql

type Mutation {
	createSampleAppsyncTable(input: CreateSampleAppsyncTableInput!): SampleAppsyncTable
		@aws_cognito_user_pools @aws_iam
	updateSampleAppsyncTable(input: UpdateSampleAppsyncTableInput!): SampleAppsyncTable
		@aws_iam
	deleteSampleAppsyncTable(input: DeleteSampleAppsyncTableInput!): SampleAppsyncTable
}

type Query @aws_cognito_user_pools {
	getSampleAppsyncTable(group: String!, path: String!): SampleAppsyncTable
	listSampleAppsyncTables(filter: TableSampleAppsyncTableFilterInput, limit: Int, nextToken: String): SampleAppsyncTableConnection
}

type SampleAppsyncTable @aws_cognito_user_pools @aws_iam {
	group: String!
	path: String!
}

Dans cet exemple, il est spécifié comme suit. Mutation.create: Cognito et IAM Mutation.update: IAM uniquement Mutation.delete: Cognito uniquement (non spécifié = principal) Requête: get et list sont uniquement Cognito

Comme je l'ai écrit jusqu'à présent, il semble bon de concevoir l'authentification principale comme étant IAM au lieu de Cognito, et de donner à Cognito l'autorisation uniquement pour ce dont le client a besoin.

Hit avec Lambda (Python)

Il s'agit d'une implémentation pour atteindre AppSync avec l'autorisation d'authentification IAM avec Python de Lambda.

sample_graphql_with_iam.py

import requests
from requests_aws4auth import AWS4Auth

AWS_REGION = os.environ["AWS_REGION"]
AWS_ACCESS_KEY_ID = os.environ["AWS_ACCESS_KEY_ID"]
AWS_SECRET_ACCESS_KEY = os.environ["AWS_SECRET_ACCESS_KEY"]
AWS_SESSION_TOKEN = os.environ["AWS_SESSION_TOKEN"]
ENDPOINT = "https://{0}.{1}.{2}.amazonaws.com/{3}".format("xxxxxxxxxxxxxxxxxxxxxx", "appsync-api", AWS_REGION, "graphql")
AUTH = AWS4Auth(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, 'appsync', session_token=AWS_SESSION_TOKEN)

def apiCreateTable(group, path):
    try:        
        body_json = {"query": 
            """
            mutation create {{
                createSampleAppsyncTable(input:{{
                group: \"{0}\"
                path: \"{1}\"
              }}){{
                group path
              }}
            }}
            """.format(group, path)
        }
        body = json.dumps(body_json)
        response = requests.request("POST", ENDPOINT, auth=AUTH, data=body, headers={})
    except Exception as e:
        logger.exception(e)
        raise e

Ajouter une stratégie au rôle IAM

Ajoutez la stratégie AppSync au rôle IAM Lambda que vous souhaitez exécuter. Tout ce que vous avez à faire est de joindre AWSAppSyncAdministrator. (* Je pense qu'il est préférable d'écrire une politique en ligne pour n'autoriser que l'API cible, pas l'ensemble AppSync, mais je ne sais pas comment l'écrire. Quelqu'un peut-il me le dire!)

Épilogue

Vous pouvez le frapper par l'avant et vous pouvez le frapper par l'arrière. Si vous attendez devant vous pour être frappé par derrière, vous vous sentirez bien. (* Histoire d'abonnement) L'avant et l'arrière sont ennuyeux avec Cognito, alors j'utilise IAM derrière. (* Histoire d'authentification)

En parlant de cela en tant que personne avec JAWS UG Hamamatsu (Oncle Amplify), j'ai eu l'idée d'écrire cet article.

En LT, à la fin de l'année dernière, j'ai utilisé ce genre d'illustration. (Image d'attente devant être frappée par derrière)

J'aimerais continuer à capturer AppSync, qui semble utile à diverses fins et mérite d'être développé!