Resources:
  # 우선 AWS Batch가 동작할 환경(EC2)을 정의합니다.
  # 주어진 VPC의 Subnet 위에 상황에 맞는 적절한 인스턴스가 생성됩니다.
  # 관리형을 선택해 자동으로 인스턴스가 늘어나고 줄어듭니다.
  # 작업이 중단되는 것을 원하지 않아 스팟 인스턴스는 적용하지 않았습니다.
  BatchComputeEnvironment:
    Type: AWS::Batch::ComputeEnvironment
    Properties:
      ComputeResources:
        InstanceRole: ecsInstanceRole
        InstanceTypes:
          - optimal
        MaxvCpus: 16
        MinvCpus: 2
        SecurityGroupIds:
          - !ImportValue VpcSecurityGroupId
        Subnets:
          - !ImportValue SubnetId1
          - !ImportValue SubnetId2
        Type: EC2
      ServiceRole: !Sub arn:aws:iam::${AWS::AccountId}:role/AWSBatchServiceRole
      Type: MANAGED

  # 다음은 작업 대기열을 설정합니다.
  # 세부적으로 나눌 필요성을 못 느껴 대부분의 작업은 default 대기열에서 실행됩니다.
  BatchQueueDefault:
    Type: AWS::Batch::JobQueue
    Properties:
      ComputeEnvironmentOrder:
        - ComputeEnvironment: !Ref BatchComputeEnvironment
          Order: 1
      JobQueueName: default
      Priority: 5
      State: ENABLED

  # 10분 이하 간격으로 실행되는 작업이 있는데
  # default 대기열에 넣으면 화면에 작업 목록이 너무 길어져서 분리했습니다.
  # 우선순위도 조금 낮게 설정했습니다.
  BatchQueueContinuously:
    Type: AWS::Batch::JobQueue
    Properties:
      ComputeEnvironmentOrder:
        - ComputeEnvironment: !Ref BatchComputeEnvironment
          Order: 1
      JobQueueName: continuously
      Priority: 3
      State: ENABLED

  # 작업을 실행할 수 있는 역할을 미리 생성해서 각 작업 정의 시 사용할 수 있도록 했습니다.
  EventsBatchSubmitJobRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - events.amazonaws.com
            Action:
              - sts:AssumeRole
      Policies:
        - PolicyName: default
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - batch:SubmitJob
                Resource:
                  - '*'

  # 작업 실패 시 실행할 람다 함수의 역할입니다.
  # 슬랙으로 메시지를 전송하는 SendToSlack이라는 함수를 호출할 수 있도록 권한을 부여했습니다.
  JobFailedAlertLambdaRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - sts:AssumeRole
      Policies:
        - PolicyName: default
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - logs:CreateLogGroup
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Resource:
                  - !Sub arn:aws:logs:ap-northeast-2:${AWS::AccountId}:*
        - PolicyName: send-to-slack
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - lambda:InvokeFunction
                Resource:
                  - !Sub arn:aws:lambda:ap-northeast-2:${AWS::AccountId}:function:SendToSlack

  # 작업 실패 시 실행되는 람다 함수입니다.
  # 실패 메시지를 분석해 적절한 에러 메시지를 슬랙으로 보내줍니다.
  JobFailedAlertLambda:
    Type: AWS::Lambda::Function
    Properties:
      Code:
        ZipFile: |
          const AWS = require('aws-sdk');
          const slackChannel = '#cron-error';

          const lambda = new AWS.Lambda({ region: 'ap-northeast-2' });

          async function processEvent(event) {
            console.log(JSON.stringify(event));
            const slackMessage = {
              channel: slackChannel,
              username: 'AWS Batch Job Failed Alert',
              icon_emoji: ':cloud:',
            };

            let color = 'danger';
            slackMessage.attachments = [{
              color: color,
              text: `${event.detail.jobName} failed by ${event.detail.statusReason}`,
            }];
            await lambda.invoke({
              FunctionName: 'SendToSlack',
              Payload: JSON.stringify(slackMessage),
            }).promise();
          }

          exports.handler = async (event, context, callback) => {
            try {
              const response = await processEvent(event);
              callback(null, response);
            } catch (error) {
              callback(error);
            }
          };          
      Handler: index.handler
      Role: !GetAtt JobFailedAlertLambdaRole.Arn
      Runtime: nodejs10.x

  # AWS Batch에서 작업 실패를 감지하면 람다 함수를 호출하도록 구성합니다.
  JobFailedEvent:
    Type: AWS::Events::Rule
    Properties:
      EventPattern:
        detail-type:
          - Batch Job State Change
        source:
          - aws.batch
        detail:
          status:
            - FAILED
      Targets:
        - Arn: !GetAtt JobFailedAlertLambda.Arn
          Id: lambda

  # 작업 실패 이벤트가 람다 함수를 실행할 수 있도록 권한을 부여합니다.
  JobFailedEventPermission:
    Type: AWS::Lambda::Permission
    Properties:
      Action: lambda:InvokeFunction
      FunctionName: !GetAtt JobFailedAlertLambda.Arn
      Principal: events.amazonaws.com
      SourceArn: !GetAtt JobFailedEvent.Arn

# 위에서 정의한 AWS Batch 리소스를 다른 CloudFormation에서 사용할 수 있도록 내보냅니다.
Outputs:
  BatchQueueArnDefault:
    Value: !Ref BatchQueueDefault
    Export:
      Name: BatchQueueArnDefault

  BatchQueueArnContinuously:
    Value: !Ref BatchQueueContinuously
    Export:
      Name: BatchQueueArnContinuously

  EventsBatchSubmitJobRoleArn:
    Value: !GetAtt EventsBatchSubmitJobRole.Arn
    Export:
      Name: EventsBatchSubmitJobRoleArn

Resources:
  # 서비스 코드가 올라간 저장소입니다.
  # 서비스 구동용 ECS 작업(task) 정의에서도 같이 사용합니다.
  Repository:
    Type: AWS::ECR::Repository
    Properties:
      RepositoryName: my-service

  # 작업을 위한 역할을 정의합니다.
  Role:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ecs-tasks.amazonaws.com
            Action:
              - sts:AssumeRole

  # 첫 번째 작업을 정의합니다.
  # 20분 정도 실행되는 작업으로 넉넉하게 30분의 시간제한을 뒀습니다.
  # 재시도는 하지 않습니다.
  DoSomethingJobDefinition:
    Type: AWS::Batch::JobDefinition
    Properties:
      ContainerProperties:
        Command: ['node', 'app/jobs/do-something']
        Image: !Sub ${AWS::AccountId}.dkr.ecr.ap-northeast-2.amazonaws.com/my-service:latest
        JobRoleArn: !Ref Role
        Memory: 1024
        Vcpus: 1
      RetryStrategy:
        Attempts: 1
      Timeout:
        AttemptDurationSeconds: 1800
      Type: container

  # 매일 아침 9시 0분(UTC 기준 새벽 0시 0분) 작업 실행하도록 CloudWatch Events를 생성합니다.
  DoSomethingEvent:
    Type: AWS::Events::Rule
    Properties:
      ScheduleExpression: cron(0 0 * * ? *)
      Targets:
        - Arn: !ImportValue BatchQueueArnDefault
          Id: task
          BatchParameters:
            JobDefinition: !Ref DoSomethingJobDefinition
            JobName: my-service-do-something
          RoleArn: !ImportValue EventsBatchSubmitJobRoleArn

  # 자주 실행하는 작업을 정의합니다.
  DoOftenJobDefinition:
    Type: AWS::Batch::JobDefinition
    Properties:
      ContainerProperties:
        Command: ['node', 'app/jobs/do-often']
        Image: !Sub ${AWS::AccountId}.dkr.ecr.ap-northeast-2.amazonaws.com/my-service:latest
        JobRoleArn: !Ref Role
        Memory: 1024
        Vcpus: 1
      RetryStrategy:
        Attempts: 1
      Timeout:
        AttemptDurationSeconds: 60
      Type: container

  # 10분마다 작업을 실행하도록 구성합니다.
  DoOftenEvent:
    Type: AWS::Events::Rule
    Properties:
      ScheduleExpression: cron(7/10 * * * ? *)
      Targets:
        - Arn: !ImportValue BatchQueueArnContinuously
          Id: task
          BatchParameters:
            JobDefinition: !Ref DoOftenJobDefinition
            JobName: my-service-do-often
          RoleArn: !ImportValue EventsBatchSubmitJobRoleArn

import AWS from 'aws-sdk';
import { JobStatus } from 'aws-sdk/clients/batch';

const job_name = 'do-something';

const batch = new AWS.Batch({ region: 'ap-northeast-2' });

async function checkAlreadyRunStatus(status: JobStatus) {
  const result = await batch.listJobs({
    jobQueue: process.env.AWS_BATCH_JQ_NAME,
    jobStatus: status,
  }).promise();
  const found = result.jobSummaryList.findIndex((item) => item.jobName === job_name && item.jobId !== process.env.AWS_BATCH_JOB_ID);
  if (found >= 0) {
    throw new Error(`already run ${result.jobSummaryList[found].jobId} / ${status}`);
  }
}

async function checkAlreadyRun() {
  await checkAlreadyRunStatus('SUBMITTED');
  await checkAlreadyRunStatus('PENDING');
  await checkAlreadyRunStatus('RUNNABLE');
  await checkAlreadyRunStatus('STARTING');
  await checkAlreadyRunStatus('RUNNING');
}

async function run() {
  try {
    await checkAlreadyRun();
  } catch (error) {
    process.exit(0); // 0으로 종료해야 실패로 처리되지 않습니다.
  }

  // 실제 수행할 코드
}

run();

import { GraphQLInt, GraphQLNonNull, GraphQLObjectType, GraphQLString } from 'graphql';

const type = new GraphQLObjectType({
  name: 'Shop',
  fields: {
    id: {
      type: new GraphQLNonNull(GraphQLInt),
    },
    name: {
      type: new GraphQLNonNull(GraphQLString),
    },
    url: {
      type: new GraphQLNonNull(GraphQLString),
    },
  },
});

import { makeExecutableSchema } from 'graphql-tools';

const typeDefs = `
type Shop {
  id: ID!
  name: String!
  url: String!
}
`;

const resolvers = {
  Query: {
    shop: ShopService.shop,
  },
};

const schema = makeExecutableSchema({
  typeDefs: [typeDefs],
  resolvers: [resolvers],
});

import { Field, ID, ObjectType } from 'type-graphql';

@ObjectType()
export class Shop {
  @Field((type) => ID, { nullable: false })
  id: string;

  @Field((type) => String, { nullable: false })
  name: string;

  @Field((type) => String, { nullable: false })
  url: string;
}

LoginInput input = LoginInput.builder().email(email).password(password).build();
apolloClient.mutate(
    LoginMutation.builder().input(input).build()
).enqueue(new ApolloCall.Callback<LoginMutation.Data>() {
    ...
});

let input = LoginInput(email: email, password: password)
apolloClient.perform(mutation: LoginMutation(input: input)) { (result, error) in
    ...
}

// api.ts (apollo-tooling 위에 자체 스크립트로 생성한 파일)
import * as types from './types';

export async function login(variable: types.LoginVariables, options?: GqlRequestOptions) {
  const query = 'mutation Login($input: LoginInput!) { login(input: $input) }';
  return await request<types.Login, types.LoginVariables>(query, variable, options);
}

// LoginView.ts
async login() {
  await api.login({
    input: { email, password },
  });
}

/// 지그재그 공지사항
struct ZigzagNotice {
  /// 레코드 ID
  1: optional i32 id
  /// 공지사항 내용
  2: optional string contents
  /// 공지 날짜
  3: optional i32 date
  /// 배포 대상 OS 타입 (0:common,1:none,2:iOS,3:Android)
  4: optional i32 os
  /// 공지사항에 필요한 링크 URL
  5: optional string link
}

service ZigzagNoticeService {
  /**
   * 해당 레코드 ID의 공지사항을 반환한다.
   *
   * fields는 ZigzagNotice의 구조체 필드 ID로 빈 경우 레코드 ID만 반환한다.
   */
  ZigzagNotice getZigzagNotice(1: i32 notice_id, 2: list<i32> fields)

  /**
   * 해당 레코드 ID의 공지사항을 업데이트 한다.
   *
   * fields는 ZigzagNotice의 구조체 필드 ID로 정의된 필드의 값만 업데이트 된다.
   */
  void updateZigzagNotice(1: i32 notice_id, 2: ZigzagNotice notice, 3: list<i32> fields)
}