에서 AWS Lambda 해석기 사용 AWS AppSync - AWS AppSync
Lambda 함수 생성Lambda용 데이터 소스 구성GraphQL 스키마 생성해석기 구성GraphQL 테스트 API오류 반환고급 사용 사례: 일괄 처리

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

에서 AWS Lambda 해석기 사용 AWS AppSync

참고

이제 APPSYNC_JS 런타임과 해당 설명서를 주로 지원합니다. 여기에서 APPSYNC_JS 런타임 및 해당 가이드를 사용하는 것이 좋습니다.

AWS Lambda 와 AWS AppSync 를 사용하여 모든 GraphQL 필드를 확인할 수 있습니다. 예를 들어 GraphQL 쿼리는 Amazon Relational Database Service(AmazonRDS) 인스턴스로 호출을 전송할 수 있으며 GraphQL 돌연변이는 Amazon Kinesis 스트림에 쓸 수 있습니다. 이 단원에서는 GraphQL 필드 작업의 호출에 따라 비즈니스 로직을 수행하는 Lambda 함수의 작성 방법을 설명합니다.

Lambda 함수 생성

다음 예는 블로그 게시물 애플리케이션의 일부로 블로그 게시물에 대해 다양한 연산을 수행하는 Node.js로 작성된 Lambda 함수를 보여줍니다.

exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got an Invoke Request.");
    switch(event.field) {
        case "getPost":
            var id = event.arguments.id;
            callback(null, posts[id]);
            break;
        case "allPosts":
            var values = [];
            for(var d in posts){
                values.push(posts[d]);
            }
            callback(null, values);
            break;
        case "addPost":
            // return the arguments back
            callback(null, event.arguments);
            break;
        case "addPostErrorWithData":
            var id = event.arguments.id;
            var result = posts[id];
            // attached additional error information to the post
            result.errorMessage = 'Error with the mutation, data has changed';
            result.errorType = 'MUTATION_ERROR';
            callback(null, result);
            break;
        case "relatedPosts":
            var id = event.source.id;
            callback(null, relatedPosts[id]);
            break;
        default:
            callback("Unknown field, unable to resolve" + event.field, null);
            break;
    }
};

Lambda 함수는 ID별로 게시물을 검색하고, 게시물을 추가하고, 게시물 목록을 가져오고, 지정된 게시물에 대해 관련 게시물을 가져오는 작업을 처리합니다.

참고: event.field에 대해 switch 명령문을 사용하면 Lambda 함수가 현재 해석 중인 필드를 확인할 수 있습니다.

AWS 관리 콘솔 또는 AWS CloudFormation 스택을 사용하여 이 Lambda 함수를 생성합니다. CloudFormation 스택에서 함수를 생성하려면 다음 AWS Command Line Interface (AWS CLI) 명령을 사용할 수 있습니다.

aws cloudformation create-stack --stack-name AppSyncLambdaExample \
--template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/lambda/LambdaCFTemplate.yaml \
--capabilities CAPABILITY_NAMED_IAM

여기에서 AWS 계정의 미국 서부(오레곤) AWS 리전에서 AWS CloudFormation 스택을 시작할 수도 있습니다.

Blue button labeled "Launch Stack" with an arrow icon indicating an action to start.

Lambda용 데이터 소스 구성

Lambda 함수를 생성한 후 콘솔API에서 AWS AppSync GraphQL로 이동한 다음 데이터 소스 탭을 선택합니다.

데이터 소스 생성을 선택하고 친숙한 데이터 소스 이름(예: Lambda)을 입력한 다음 데이터 소스 유형에서 AWS Lambda 함수를 선택합니다. 리전에서 함수와 동일한 리전을 선택합니다. (제공된 CloudFormation 스택에서 함수를 생성한 경우 함수는 US-WEST-2에 있을 수 있습니다.) 함수 ARN에서 Lambda 함수의 Amazon 리소스 이름(ARN)을 선택합니다.

Lambda 함수를 선택한 후 새 AWS Identity and Access Management (IAM) 역할(적절한 권한을 AWS AppSync 할당하는 역할)을 생성하거나 다음과 같은 인라인 정책이 있는 기존 역할을 선택할 수 있습니다.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": "arn:aws:lambda:REGION:ACCOUNTNUMBER:function/LAMBDA_FUNCTION"
        }
    ]
}

또한 다음과 같이 IAM 역할에 AWS AppSync 대해 와 신뢰 관계를 설정해야 합니다.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "appsync.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

GraphQL 스키마 생성

이제 데이터 소스가 Lambda 함수에 연결되었으며 GraphQL 스키마를 생성해 보겠습니다.

AWS AppSync 콘솔의 스키마 편집기에서 스키마가 다음 스키마와 일치하는지 확인합니다.

schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id:ID!): Post
    allPosts: [Post]
}

type Mutation {
    addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!
}

type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    relatedPosts: [Post]
}

해석기 구성

이제 Lambda 데이터 소스와 유효한 GraphQL 스키마를 등록했으며, 해석기를 사용하여 GraphQL 필드를 Lambda 데이터 소스에 연결할 수 있습니다.

해석기를 생성하려면 매핑 템플릿이 필요합니다. 매핑 템플릿에 대한 자세히 알아보려면 Resolver Mapping Template Overview 단원을 참조하세요.

Lambda 매핑 템플릿에 대한 자세한 내용은 Resolver mapping template reference for Lambda 단원을 참조하세요.

이 단계에서는 getPost(id:ID!): Post, allPosts: [Post], addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!, Post.relatedPosts: [Post] 필드에 대한 해석기를 Lambda 함수에 연결합니다.

AWS AppSync 콘솔의 스키마 편집기 오른쪽에서 에 대한 해석기 연결을 선택합니다getPost(id:ID!): Post.

그런 다음 작업 메뉴 에서 런타임 업데이트를 선택한 다음 Unit Resolver(VTL만 해당)를 선택합니다.

그런 다음 Lambda 데이터 소스를 선택합니다. request mapping template(요청 매핑 템플릿) 섹션에서 Invoke And Forward Arguments(인수 호출 및 전달)을 선택합니다.

payload 객체를 수정하여 필드 이름을 추가합니다. 템플릿은 다음과 같아야 합니다.

{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments":  $utils.toJson($context.arguments)
    }
}

response mapping template(요청 매핑 템플릿) 섹션에서 Return Lambda Result(Lambda 결과 반환)를 선택합니다.

이 경우에는 기본 템플릿을 있는 그대로 사용하겠습니다. 이 템플릿은 다음과 같습니다.

$utils.toJson($context.result)

저장(Save)을 선택합니다. 이제 첫 번째 해석기를 성공적으로 연결했습니다. 다음과 같이 나머지 필드에 대해 이 작업을 반복합니다.

addPost(id: ID!, author: String!, title: String, content: String, url: String): Post! 요청 매핑 템플릿

{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "addPost",
        "arguments":  $utils.toJson($context.arguments)
    }
}

addPost(id: ID!, author: String!, title: String, content: String, url: String): Post! 응답 매핑 템플릿

$utils.toJson($context.result)

allPosts: [Post] 요청 매핑 템플릿

{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "allPosts"
    }
}

allPosts: [Post] 응답 매핑 템플릿

$utils.toJson($context.result)

Post.relatedPosts: [Post] 요청 매핑 템플릿

{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "relatedPosts",
        "source":  $utils.toJson($context.source)
    }
}

Post.relatedPosts: [Post] 응답 매핑 템플릿

$utils.toJson($context.result)

GraphQL 테스트 API

Lambda 함수가 GraphQL 해석기에 연결되었으므로 콘솔이나 클라이언트 애플리케이션을 사용하여 뮤테이션 및 쿼리를 실행할 수 있습니다.

AWS AppSync 콘솔 왼쪽에서 쿼리를 선택한 다음 다음 다음 코드에 붙여넣습니다.

addPost 돌연변이

mutation addPost {
    addPost(
        id: 6
        author: "Author6"
        title: "Sixth book"
        url: "https://www.amazon.com/"
        content: "This is the book is a tutorial for using GraphQL with AWS AppSync."
    ) {
        id
        author
        title
        content
        url
        ups
        downs
    }
}

getPost 쿼리

query getPost {
    getPost(id: "2") {
        id
        author
        title
        content
        url
        ups
        downs
    }
}

allPosts 쿼리

query allPosts {
    allPosts {
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {
            id
            title
        }
    }
}

오류 반환

필드 해상도를 지정하면 오류가 발생할 수 있습니다. 를 사용하면 다음 소스에서 오류를 발생 AWS AppSync시킬 수 있습니다.

  • 요청 또는 응답 매핑 템플릿

  • Lambda 함수

매핑 템플릿에서

의도적인 오류를 발생시키려면 Velocity 템플릿 언어(VTL) 템플릿의 $utils.error 헬퍼 메서드를 사용할 수 있습니다. errorMessage, errorType 및 선택적 data 값을 인수로 사용합니다. data는 오류가 발생한 경우 외부 데이터를 클라이언트로 반환할 때 유용합니다. GraphQL 최종 응답에서 errors에 data 객체가 추가됩니다.

다음 예시는 Post.relatedPosts: [Post] 응답 매핑 템플릿에서 이 데이터 객체를 사용하는 방법을 보여줍니다.

$utils.error("Failed to fetch relatedPosts", "LambdaFailure", $context.result)

다음과 유사한 GraphQL 응답이 산출됩니다.

{
    "data": {
        "allPosts": [
            {
                "id": "2",
                "title": "Second book",
                "relatedPosts": null
            },
            ...
        ]
    },
    "errors": [
        {
            "path": [
                "allPosts",
                0,
                "relatedPosts"
            ],
            "errorType": "LambdaFailure",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ],
            "message": "Failed to fetch relatedPosts",
            "data": [
                {
                  "id": "2",
                  "title": "Second book"
                },
                {
                  "id": "1",
                  "title": "First book"
                }
            ]
        }
    ]
}

여기서 allPosts[0].relatedPosts는 오류로 인해 null이며 errorMessage, errorType 및 data가 data.errors[0] 객체 안에 있습니다.

Lambda 함수에서

AWS AppSync 또한 는 Lambda 함수가 발생시키는 오류를 이해합니다. Lambda 프로그래밍 모델은 handled 오류를 발생시킵니다. Lambda 함수에서 오류가 발생하면 가 현재 필드를 해결하지 AWS AppSync 못합니다. Lambda에서 반환되는 오류 메시지만 응답에 설정됩니다. 현재는 Lambda 함수에서 오류를 발생시켜 관련 없는 데이터를 클라이언트에 다시 전달할 수 없습니다.

참고: Lambda 함수에서 처리되지 않은 오류가 발생하면 Lambda가 설정한 오류 메시지를 AWS AppSync 사용합니다.

다음 Lambda 함수는 오류를 발생시킵니다.

exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    callback("I fail. Always.");
};

다음과 유사한 GraphQL 응답이 반환됩니다.

{
    "data": {
        "allPosts": [
            {
                "id": "2",
                "title": "Second book",
                "relatedPosts": null
            },
            ...
        ]
    },
    "errors": [
        {
            "path": [
                "allPosts",
                0,
                "relatedPosts"
            ],
            "errorType": "Lambda:Handled",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ],
            "message": "I fail. Always."
        }
    ]
}

고급 사용 사례: 일괄 처리

이 예제의 Lambda 함수에는 해당 게시물에 대한 관련 게시물 목록을 반환하는 relatedPosts 필드가 있습니다. 예제 쿼리에서 Lambda 함수의 allPosts 필드 호출은 5개 게시물을 반환합니다. 각각의 반환된 게시물에 대해 relatedPosts를 해석하도록 지정했으므로 relatedPosts 필드 작업이 5회 호출됩니다.

query allPosts {
    allPosts {   // 1 Lambda invocation - yields 5 Posts
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {   // 5 Lambda invocations - each yields 5 posts
            id
            title
        }
    }
}

이 특정 예제에서는 큰 문제가 되지 않을 수 있지만, 이러한 복합적이고 과도한 가져오기로 인해 애플리케이션이 빠르게 손상될 수 있습니다.

동일한 쿼리에서 반환된 관련 Posts에 대해 relatedPosts를 다시 가져오려 할 경우 호출 횟수가 크게 증가할 것입니다.

query allPosts {
    allPosts {   // 1 Lambda invocation - yields 5 Posts
        id
        author
        title
        content
        url
        ups
        downs
        relatedPosts {   // 5 Lambda invocations - each yield 5 posts = 5 x 5 Posts
            id
            title
            relatedPosts {  // 5 x 5 Lambda invocations - each yield 5 posts = 25 x 5 Posts
                id
                title
                author
            }
        }
    }
}

이 비교적 간단한 쿼리에서는 Lambda 함수 1 + 5 + 25 = 31회를 호출 AWS AppSync 합니다.

이는 상당히 일반적인 문제로 대개 N+1 문제(이 경우에 N = 5)라고도 하며 이로 인해 애플리케이션의 지연 시간 및 비용이 증가될 수 있습니다.

이 문제를 해결하는 한 가지 방법은 유사한 필드 해석기 요청을 하나로 묶는 것입니다. 이 예제에서는 지정된 단일 게시물에 대한 관련 게시물 목록을 해석하는 Lambda 함수 하나 대신에, 해당 게시물 배치에 대한 관련 게시물 목록을 해석합니다.

예시를 배치위해 Post.relatedPosts: [Post] 해석기를 배치 활성화된 해석기로 전환하겠습니다.

AWS AppSync 콘솔 오른쪽에서 기존 Post.relatedPosts: [Post] 해석기를 선택합니다. 요청 매핑 템플릿을 다음으로 변경합니다.

{
    "version": "2017-02-28",
    "operation": "BatchInvoke",
    "payload": {
        "field": "relatedPosts",
        "source":  $utils.toJson($context.source)
    }
}

operation 필드만 Invoke에서 BatchInvoke로 변경되었습니다. 이제 페이로드 필드가 템플릿에 지정된 배열이 됩니다. 이 예제에서는 Lambda 함수가 다음을 입력으로 수신합니다.

[
    {
        "field": "relatedPosts",
        "source": {
            "id": 1
        }
    },
    {
        "field": "relatedPosts",
        "source": {
            "id": 2
        }
    },
    ...
]

BatchInvoke가 요청 매핑 템플릿에 지정되었으면 Lambda 함수가 요청 목록을 수신하고 결과 목록을 반환합니다.

특히 결과 목록은 요청 페이로드 항목의 크기 및 순서와 일치해야 가 결과에 맞게 일치할 AWS AppSync 수 있습니다.

이 일괄 처리 예제에서 Lambda 함수는 다음과 같이 결과의 배치를 반환합니다.

[
    [{"id":"2","title":"Second book"}, {"id":"3","title":"Third book"}],   // relatedPosts for id=1
    [{"id":"3","title":"Third book"}]                                                             // relatedPosts for id=2
]

Node.js의 다음 Lambda 함수는 다음과 같이 Post.relatedPosts 필드에 대한 이 일괄 처리 기능을 보여줍니다.

exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
    // event is now an array
    var field = event[0].field;
    switch(field) {
        case "relatedPosts":
            var results = [];
            // the response MUST contain the same number
            // of entries as the payload array
            for (var i=0; i< event.length; i++) {
                console.log("post {}", JSON.stringify(event[i].source));
                results.push(relatedPosts[event[i].source.id]);
            }
            console.log("results {}", JSON.stringify(results));
            callback(null, results);
            break;
        default:
            callback("Unknown field, unable to resolve" + field, null);
            break;
    }
};

개별 오류 반환

앞의 예에서는 Lambda 함수에서 단일 오류가 반환되거나 매핑 템플릿에서 오류를 일으킬 수 있음을 보았습니다. 일괄 처리된 호출의 경우, Lambda 함수에서 오류가 발생하면 전체 배치가 실패로 플래그 지정됩니다. 이는 데이터 스토어와의 연결 중단 같은 취소 불가능한 오류가 발생하는 특정 시나리오를 잘 설명할 수 있습니다. 하지만 배치의 일부 항목이 성공하고 다른 항목이 실패하는 경우, 오류 및 유효한 데이터를 모두 반환할 수 있습니다. AWS AppSync 는 배치의 원래 크기와 일치하는 요소를 나열하는 배치 응답을 요구하므로 유효한 데이터를 오류와 구분할 수 있는 데이터 구조를 정의해야 합니다.

예를 들어 Lambda 함수가 관련 게시물 배치를 반환할 것으로 예상되는 경우 각 Response 객체에 선택적 데이터 , errorMessage및 errorType 필드가 있는 객체 목록을 반환하도록 선택할 수 있습니다. errorMessage 필드가 있는 경우 오류가 발생했음을 의미합니다.

다음 코드는 Lambda 함수를 업데이트하는 방법을 보여줍니다.

exports.handler = (event, context, callback) => {
    console.log("Received event {}", JSON.stringify(event, 3));
    var posts = {
         "1": {"id": "1", "title": "First book", "author": "Author1", "url": "https://amazon.com/", "content": "SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1", "ups": "100", "downs": "10"},
         "2": {"id": "2", "title": "Second book", "author": "Author2", "url": "https://amazon.com", "content": "SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT", "ups": "100", "downs": "10"},
         "3": {"id": "3", "title": "Third book", "author": "Author3", "url": null, "content": null, "ups": null, "downs": null },
         "4": {"id": "4", "title": "Fourth book", "author": "Author4", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4", "ups": "1000", "downs": "0"},
         "5": {"id": "5", "title": "Fifth book", "author": "Author5", "url": "https://www.amazon.com/", "content": "SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT", "ups": "50", "downs": "0"} };

    var relatedPosts = {
        "1": [posts['4']],
        "2": [posts['3'], posts['5']],
        "3": [posts['2'], posts['1']],
        "4": [posts['2'], posts['1']],
        "5": []
    };

    console.log("Got a BatchInvoke Request. The payload has %d items to resolve.", event.length);
    // event is now an array
    var field = event[0].field;
    switch(field) {
        case "relatedPosts":
            var results = [];
            results.push({ 'data': relatedPosts['1'] });
            results.push({ 'data': relatedPosts['2'] });
            results.push({ 'data': null, 'errorMessage': 'Error Happened', 'errorType': 'ERROR' });
            results.push(null);
            results.push({ 'data': relatedPosts['3'], 'errorMessage': 'Error Happened with last result', 'errorType': 'ERROR' });
            callback(null, results);
            break;
        default:
            callback("Unknown field, unable to resolve" + field, null);
            break;
    }
};

이 예의 경우,다음의 응답 매핑 템플릿을 통해 Lambda 함수의 각 항목과 발생하는 모든 오류를 구문 분석할 수 있습니다.

#if( $context.result && $context.result.errorMessage )
    $utils.error($context.result.errorMessage, $context.result.errorType, $context.result.data)
#else
    $utils.toJson($context.result.data)
#end

이 예에서는 다음과 유사한 GraphQL 응답이 반환됩니다.

{
  "data": {
    "allPosts": [
      {
        "id": "1",
        "relatedPostsPartialErrors": [
          {
            "id": "4",
            "title": "Fourth book"
          }
        ]
      },
      {
        "id": "2",
        "relatedPostsPartialErrors": [
          {
            "id": "3",
            "title": "Third book"
          },
          {
            "id": "5",
            "title": "Fifth book"
          }
        ]
      },
      {
        "id": "3",
        "relatedPostsPartialErrors": null
      },
      {
        "id": "4",
        "relatedPostsPartialErrors": null
      },
      {
        "id": "5",
        "relatedPostsPartialErrors": null
      }
    ]
  },
  "errors": [
    {
      "path": [
        "allPosts",
        2,
        "relatedPostsPartialErrors"
      ],
      "errorType": "ERROR",
      "locations": [
        {
          "line": 4,
          "column": 9
        }
      ],
      "message": "Error Happened"
    },
    {
      "path": [
        "allPosts",
        4,
        "relatedPostsPartialErrors"
      ],
      "data": [
        {
          "id": "2",
          "title": "Second book"
        },
        {
          "id": "1",
          "title": "First book"
        }
      ],
      "errorType": "ERROR",
      "locations": [
        {
          "line": 4,
          "column": 9
        }
      ],
      "message": "Error Happened with last result"
    }
  ]
}

최대 배치 크기 구성

기본적으로 를 사용하는 경우 BatchInvoke는 Lambda 함수에 최대 5개 항목의 배치로 요청을 AWS AppSync 보냅니다. Lambda 해석기의 최대 배치 크기를 구성할 수 있습니다.

해석기에서 최대 배치 크기를 구성하려면 AWS Command Line Interface ()에서 다음 명령을 사용합니다AWS CLI.

$ aws appsync create-resolver --api-id <api-id> --type-name Query --field-name relatedPosts \
 --request-mapping-template "<template>" --response-mapping-template "<template>" --data-source-name "<lambda-datasource>" \ 
 --max-batch-size X
참고

요청 매핑 템플릿을 제공할 때는 BatchInvoke 작업을 사용하여 일괄 처리를 사용해야 합니다.

다음 명령을 사용하여 직접 Lambda 해석기에서 일괄 처리를 활성화하고 구성할 수도 있습니다.

$ aws appsync create-resolver --api-id <api-id> --type-name Query --field-name relatedPosts \
 --data-source-name "<lambda-datasource>" \ 
 --max-batch-size X

VTL 템플릿을 사용한 최대 배치 크기 구성

요청 VTL 내 템플릿이 있는 Lambda 해석기의 경우 에서 BatchInvoke 작업으로 직접 지정하지 않는 한 최대 배치 크기는 영향을 받지 않습니다VTL. 마찬가지로 최상위 뮤테이션을 수행하는 경우 GraphQL 사양에서 병렬 뮤테이션을 순차적으로 실행하도록 요구하기 때문에 뮤테이션에 대한 일괄 처리가 수행되지 않습니다.

예를 들어, 다음과 같은 뮤테이션이 있다고 가정합니다.

type Mutation {
    putItem(input: Item): Item
    putItems(inputs: [Item]): [Item]
}

첫 번째 뮤테이션을 사용하여 아래 코드 조각과 같이 10개 Items를 생성할 수 있습니다.

mutation MyMutation {
    v1: putItem($someItem1) {
        id,
        name
    }
    v2: putItem($someItem2) {
        id,
        name
    }
    v3: putItem($someItem3) {
        id,
        name
    } 
    v4: putItem($someItem4) {
        id,
        name
    }
    v5: putItem($someItem5) {
        id,
        name
    }
    v6: putItem($someItem6) {
        id,
        name
    } 
    v7: putItem($someItem7) {
        id,
        name
    }
    v8: putItem($someItem8) {
        id,
        name
    }
    v9: putItem($someItem9) {
        id,
        name
    }
    v10: putItem($someItem10) {
        id,
        name
    }
}

이 예제에서는 Lambda 해석기에서 최대 일괄 처리 크기가 10으로 설정되어 있어도 Items는 10개의 그룹으로 일괄 처리되지 않습니다. 대신 GraphQL 사양에 따라 순차적으로 실행됩니다.

실제 배치 뮤테이션을 수행하려면 다음 예제를 따라 두 번째 뮤테이션을 사용할 수 있습니다.

mutation MyMutation {
    putItems([$someItem1, $someItem2, $someItem3,$someItem4, $someItem5, $someItem6, 
    $someItem7, $someItem8, $someItem9, $someItem10]) {
    id,
    name
    }
}

직접 Lambda 해석기를 사용한 일괄 처리 사용에 대한 자세한 내용은 Direct Lambda 해석기 단원을 참조하세요.