Go 언어에서의 GraphQL 서버 구현: 초보자도 쉽게 따라할 수 있는 가이드 🚀

안녕, 친구들! 오늘은 정말 흥미진진한 주제로 여러분과 함께할 거야. 바로 Go 언어를 사용해서 GraphQL 서버를 구현하는 방법에 대해 알아볼 거거든. 😎 이 글을 읽고 나면, 너희도 충분히 GraphQL 서버를 만들 수 있을 거야. 그럼 어서 시작해보자!

참고: 이 글은 '재능넷'의 '지식인의 숲' 메뉴에 등록될 예정이야. 재능넷은 다양한 재능을 거래하는 플랫폼인데, 여기서 배운 Go와 GraphQL 지식으로 멋진 프로젝트를 만들어 공유해볼 수도 있겠지? 🌟

1. GraphQL이 뭐길래? 🤔

자, 먼저 GraphQL이 뭔지부터 알아보자. GraphQL은 페이스북에서 만든 쿼리 언어야. REST API의 한계를 극복하기 위해 탄생했다고 볼 수 있지. GraphQL을 사용하면 클라이언트가 필요한 데이터만 정확하게 요청할 수 있어. 이게 무슨 말이냐고? 예를 들어볼게.

🍕 피자 주문 시스템을 상상해봐. REST API를 사용한다면:

/pizzas: 모든 피자 정보를 가져옴
/toppings: 모든 토핑 정보를 가져옴
/orders: 주문 정보를 가져옴

이렇게 여러 번의 요청이 필요할 수 있어. 하지만 GraphQL을 사용하면:


query {
  pizza(id: 1) {
    name
    toppings {
      name
    }
    orders {
      customerName
      orderDate
    }
  }
}

이렇게 한 번의 요청으로 필요한 모든 정보를 가져올 수 있지!

GraphQL의 장점은 여기서 끝이 아니야. 버전 관리가 쉽고, 강력한 개발자 도구를 제공하며, 타입 시스템을 통해 데이터의 형태를 명확하게 정의할 수 있어. 이런 장점들 때문에 많은 기업들이 GraphQL을 도입하고 있지.

위 그래프를 보면 GraphQL이 REST API보다 얼마나 효율적인지 한눈에 알 수 있지? 😉

2. Go 언어로 GraphQL 서버를 만들자! 💪

자, 이제 본격적으로 Go 언어를 사용해서 GraphQL 서버를 만들어볼 거야. Go는 성능이 뛰어나고 동시성 처리가 쉬워서 서버 개발에 아주 적합한 언어야. GraphQL 서버를 구현하는 데에도 딱이지!

먼저, 필요한 라이브러리부터 설치해보자.


go get github.com/graphql-go/graphql
go get github.com/graphql-go/handler

이 두 라이브러리가 우리의 GraphQL 여정에 큰 도움을 줄 거야. 😊

이제 간단한 GraphQL 스키마를 정의해볼게.


package main

import (
    "github.com/graphql-go/graphql"
    "github.com/graphql-go/handler"
    "net/http"
    "log"
)

var userType = graphql.NewObject(
    graphql.ObjectConfig{
        Name: "User",
        Fields: graphql.Fields{
            "id": &graphql.Field{
                Type: graphql.Int,
            },
            "name": &graphql.Field{
                Type: graphql.String,
            },
            "age": &graphql.Field{
                Type: graphql.Int,
            },
        },
    },
)

var queryType = graphql.NewObject(
    graphql.ObjectConfig{
        Name: "Query",
        Fields: graphql.Fields{
            "user": &graphql.Field{
                Type: userType,
                Args: graphql.FieldConfigArgument{
                    "id": &graphql.ArgumentConfig{
                        Type: graphql.Int,
                    },
                },
                Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                    id, ok := p.Args["id"].(int)
                    if ok {
                        // 여기서 실제로는 데이터베이스에서 사용자를 조회해야 해
                        return map[string]interface{}{
                            "id":   id,
                            "name": "John Doe",
                            "age":  30,
                        }, nil
                    }
                    return nil, nil
                },
            },
        },
    },
)

var schema, _ = graphql.NewSchema(
    graphql.SchemaConfig{
        Query: queryType,
    },
)

func main() {
    h := handler.New(&handler.Config{
        Schema: &schema,
        Pretty: true,
    })

    http.Handle("/graphql", h)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

우와, 코드가 좀 길지? 하나씩 뜯어보자!

userType: 사용자 정보를 나타내는 GraphQL 객체 타입을 정의했어.
queryType: GraphQL 쿼리의 진입점을 정의했어. 여기서는 'user' 필드 하나만 있지.
Resolve 함수: 실제로 데이터를 가져오는 로직을 구현하는 부분이야. 여기서는 간단히 하드코딩했지만, 실제로는 데이터베이스에서 조회하는 로직이 들어가야 해.
schema: 전체 GraphQL 스키마를 정의했어.
main 함수: GraphQL 핸들러를 생성하고 HTTP 서버를 시작하는 부분이야.

이렇게 하면 기본적인 GraphQL 서버가 완성돼! 이제 http://localhost:8080/graphql 주소로 접속하면 GraphQL 플레이그라운드를 볼 수 있을 거야. 여기서 쿼리를 직접 실행해볼 수 있지.

팁: 재능넷에서 GraphQL 관련 프로젝트를 찾아보면, 이런 기본적인 서버 구현을 넘어선 다양한 활용 사례를 볼 수 있을 거야. 다른 개발자들의 경험을 참고해보는 것도 좋은 방법이지! 🌈

3. GraphQL 쿼리 실행하기 🏃‍♂️

자, 이제 우리가 만든 GraphQL 서버에 쿼리를 날려볼 차례야. GraphQL 플레이그라운드에서 다음과 같은 쿼리를 실행해보자.


query {
  user(id: 1) {
    id
    name
    age
  }
}

그러면 다음과 같은 결과를 받을 수 있을 거야:


{
  "data": {
    "user": {
      "id": 1,
      "name": "John Doe",
      "age": 30
    }
  }
}

짜잔! 우리가 만든 GraphQL 서버가 잘 동작하고 있어! 😄

4. GraphQL 서버 확장하기 🚀

기본적인 서버는 만들었지만, 실제 애플리케이션에서는 이것보다 훨씬 복잡한 스키마와 리졸버가 필요할 거야. 예를 들어, 사용자의 게시물을 가져오는 기능을 추가해보자.


var postType = graphql.NewObject(
    graphql.ObjectConfig{
        Name: "Post",
        Fields: graphql.Fields{
            "id": &graphql.Field{
                Type: graphql.Int,
            },
            "title": &graphql.Field{
                Type: graphql.String,
            },
            "content": &graphql.Field{
                Type: graphql.String,
            },
            "author": &graphql.Field{
                Type: userType,
            },
        },
    },
)

var queryType = graphql.NewObject(
    graphql.ObjectConfig{
        Name: "Query",
        Fields: graphql.Fields{
            "user": &graphql.Field{
                Type: userType,
                Args: graphql.FieldConfigArgument{
                    "id": &graphql.ArgumentConfig{
                        Type: graphql.Int,
                    },
                },
                Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                    // 기존 코드...
                },
            },
            "post": &graphql.Field{
                Type: postType,
                Args: graphql.FieldConfigArgument{
                    "id": &graphql.ArgumentConfig{
                        Type: graphql.Int,
                    },
                },
                Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                    id, ok := p.Args["id"].(int)
                    if ok {
                        // 여기서 실제로는 데이터베이스에서 게시물을 조회해야 해
                        return map[string]interface{}{
                            "id":      id,
                            "title":   "My First Post",
                            "content": "Hello, GraphQL!",
                            "author": map[string]interface{}{
                                "id":   1,
                                "name": "John Doe",
                                "age":  30,
                            },
                        }, nil
                    }
                    return nil, nil
                },
            },
        },
    },
)

이제 게시물 정보도 조회할 수 있게 됐어! 다음과 같은 쿼리로 게시물과 작성자 정보를 한 번에 가져올 수 있지:


query {
  post(id: 1) {
    id
    title
    content
    author {
      name
      age
    }
  }
}

이렇게 GraphQL의 강력한 기능을 활용하면, 클라이언트가 필요한 데이터만 정확하게 요청할 수 있어. REST API였다면 여러 번의 요청이 필요했을 텐데, GraphQL을 사용하면 한 번의 요청으로 모든 정보를 가져올 수 있지!

5. 데이터베이스 연동하기 🗃️

지금까지는 하드코딩된 데이터를 반환했지만, 실제 애플리케이션에서는 데이터베이스를 사용해야 해. Go에서는 보통 database/sql 패키지를 사용해 데이터베이스와 연동하지. 예를 들어, MySQL을 사용한다면 이렇게 할 수 있어:


import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("mysql", "user:password@/dbname")
    if err != nil {
        log.Fatal(err)
    }
}

// user 리졸버 수정
"user": &graphql.Field{
    // ...
    Resolve: func(p graphql.ResolveParams) (interface{}, error) {
        id, ok := p.Args["id"].(int)
        if ok {
            var user struct {
                ID   int
                Name string
                Age  int
            }
            err := db.QueryRow("SELECT id, name, age FROM users WHERE id = ?", id).Scan(&user.ID, &user.Name, &user.Age)
            if err != nil {
                return nil, err
            }
            return user, nil
        }
        return nil, nil
    },
},

이제 실제 데이터베이스에서 사용자 정보를 가져오고 있어! 물론 실제 프로덕션 환경에서는 에러 처리나 커넥션 풀링 등 더 많은 것들을 고려해야 하지만, 기본적인 개념은 이해했을 거야. 😊

6. 뮤테이션 추가하기 ✏️

GraphQL에서는 데이터를 변경하는 작업을 뮤테이션(Mutation)이라고 불러. 사용자를 추가하는 뮤테이션을 만들어볼까?


var mutationType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Mutation",
    Fields: graphql.Fields{
        "createUser": &graphql.Field{
            Type: userType,
            Args: graphql.FieldConfigArgument{
                "name": &graphql.ArgumentConfig{
                    Type: graphql.NewNonNull(graphql.String),
                },
                "age": &graphql.ArgumentConfig{
                    Type: graphql.NewNonNull(graphql.Int),
                },
            },
            Resolve: func(p graphql.ResolveParams) (interface{}, error) {
                name, _ := p.Args["name"].(string)
                age, _ := p.Args["age"].(int)

                // 데이터베이스에 사용자 추가
                result, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", name, age)
                if err != nil {
                    return nil, err
                }

                id, _ := result.LastInsertId()

                return map[string]interface{}{
                    "id":   id,
                    "name": name,
                    "age":  age,
                }, nil
            },
        },
    },
})

// 스키마에 뮤테이션 추가
var schema, _ = graphql.NewSchema(
    graphql.SchemaConfig{
        Query:    queryType,
        Mutation: mutationType,
    },
)

이제 다음과 같은 뮤테이션으로 새로운 사용자를 추가할 수 있어:


mutation {
  createUser(name: "Alice", age: 25) {
    id
    name
    age
  }
}

뮤테이션을 사용하면 GraphQL을 통해 데이터를 생성, 수정, 삭제할 수 있어. 정말 편리하지? 😎

7. 서브스크립션 구현하기 🔔

GraphQL의 또 다른 강력한 기능 중 하나는 서브스크립션이야. 서브스크립션을 사용하면 실시간으로 데이터 변경 사항을 클라이언트에 푸시할 수 있지. Go에서 서브스크립션을 구현하려면 웹소켓을 사용해야 해. 예를 들어, 새로운 사용자가 추가될 때마다 알림을 받고 싶다면 이렇게 구현할 수 있어: