init 251117

2025-11-17 23:25:36 +09:00
commit 734f3af161
18 changed files with 1761 additions and 0 deletions
@@ -0,0 +1 @@
+GEMINI_API_KEY="AIzaSyB3yPk3Uljj-tLlANaJg3YVL1st6yqxCaA"
@@ -0,0 +1,4 @@
+# 역할
+- 영어로 작성된 파일을 한국어로 번역
+- 번역된 표현에서 어색한 한국어 표현 수정 및 내용을 더욱 쉽게 이해할 수 있도록 내용 추가
+- 내용의 흐름은 바꾸지 말 것!
@@ -0,0 +1,70 @@
+# JSON이란?
+
+
+# HTTP란?
+
+## `gin-gonic`을 이용한 http 서버 구현하기
+
+
+
+- 참고 자료
+  - 
+
+# gRPC란?
+
+이번 장에서는 Go 언어에서 gRPC를 어떻게 활용하는지 전반적으로 살펴보겠습니다.
+
+### gRPC 개요
+
+이 장은 Go 언어를 사용하여 gRPC를 다루는 방법을 설명합니다. gRPC는 'gRPC Remote Procedure Calls'의 약자로, 구글이 개발한 RESTful 서비스의 대안입니다. gRPC의 가장 큰 장점은 REST와 JSON 메시지를 사용하는 방식보다 훨씬 빠르다는 점입니다.
+
+또한, gRPC는 풍부한 도구들을 제공하여 gRPC 서비스용 클라이언트를 더 빠르고 쉽게 만들 수 있도록 돕습니다. 마지막으로, gRPC는 바이너리 데이터 형식을 사용하기 때문에 JSON 형식을 사용하는 RESTful 서비스보다 훨씬 가볍습니다.
+
+gRPC 서버와 클라이언트를 개발하는 과정은 크게 세 단계로 나뉩니다. 첫째, 인터페이스 정의 언어(IDL) 파일을 생성합니다. 둘째, gRPC 서버를 개발합니다. 셋째, 개발된 gRPC 서버와 통신할 gRPC 클라이언트를 개발합니다.
+
+### 다룰 주제
+
+이번 장에서는 다음 주제들을 다룹니다:
+
+- gRPC 소개
+- 인터페이스 정의 언어(IDL) 파일 정의
+- gRPC 서버 개발
+- gRPC 클라이언트 개발
+
+## gRPC 소개
+
+gRPC의 이점과 프로토콜 버퍼에 대해 자세히 알아보겠습니다.
+
+gRPC는 2015년 구글이 개발한 오픈소스 원격 프로시저 호출(RPC) 시스템입니다. HTTP/2를 기반으로 구축되어 서비스 개발을 용이하게 하며, 메시지 형식과 서비스 인터페이스를 정의하는 IDL(인터페이스 정의 언어)로 프로토콜 버퍼를 사용합니다.
+
+gRPC 클라이언트와 서버는 서로 다른 프로그래밍 언어로 작성될 수 있습니다. 예를 들어, gRPC 서버가 Go 언어로 구현되었더라도 클라이언트는 Python으로 개발할 수 있습니다. 지원되는 프로그래밍 언어는 Python, Java, C++, C#, PHP, Ruby, Kotlin 등 다양합니다.
+
+### 장점
+
+gRPC의 주요 장점은 다음과 같습니다:
+
+- **빠른 데이터 교환**: 바이너리 데이터 형식을 사용하여 일반 텍스트 기반 서비스보다 훨씬 빠르게 데이터를 교환합니다.
+- **간편한 개발 도구**: 풍부한 명령줄 도구들을 제공하여 개발 작업을 더욱 간단하고 신속하게 만듭니다.
+- **쉬운 서버/클라이언트 생성**: gRPC 서비스의 함수와 메시지를 정의한 후에는 RESTful 서비스보다 서버와 클라이언트를 더 쉽게 생성할 수 있습니다.
+- **스트리밍 지원**: 스트리밍 서비스에 효과적으로 활용될 수 있습니다.
+- **세부 사항 자동 처리**: 데이터 교환의 복잡한 세부 사항을 gRPC가 자동으로 처리해주므로 개발자가 신경 쓸 필요가 없습니다.
+
+> 참고: 이 장점 목록만 보고 gRPC가 모든 문제의 완벽한 해결책이라고 오해해서는 안 됩니다. 항상 현재 작업에 가장 적합한 도구나 기술을 선택하는 것이 중요합니다.
+
+다음 섹션에서는 gRPC 서비스의 핵심 기반 기술인 프로토콜 버퍼에 대해 자세히 알아보겠습니다.
+
+### 프로토콜 버퍼
+
+프로토콜 버퍼(Protobuf)는 구조화된 데이터를 효율적으로 직렬화하는 방법입니다. Protobuf는 IDL(인터페이스 정의 언어)의 일부로, 데이터 교환 시 바이너리 형식을 사용하기 때문에 일반 텍스트 기반 직렬화 형식보다 훨씬 적은 공간을 차지합니다. 하지만 데이터를 기계가 사용하고 사람이 읽을 수 있도록 하려면 각각 인코딩과 디코딩 과정이 필요합니다. Protobuf는 각 프로그래밍 언어에서 기본적으로 지원하는 데이터 타입으로 변환되는 자체 데이터 타입을 제공합니다.
+
+![alt text](README.assets/images/proto_buf.png)
+
+일반적으로 IDL 파일은 모든 gRPC 서비스의 핵심입니다. 이는 데이터 교환 형식과 서비스 인터페이스를 정의하기 때문입니다. Protobuf 파일 없이는 gRPC 서비스를 구축할 수 없습니다. 더 정확히 말하면, Protobuf 파일에는 서비스 정의, 서비스 메서드, 그리고 교환될 메시지 형식이 모두 포함됩니다. 따라서 gRPC 서비스를 이해하려면 해당 정의 파일을 살펴보는 것이 가장 중요하다고 할 수 있습니다. 다음 레슨에서는 우리가 만들 gRPC 서비스에 사용될 Protobuf 파일을 자세히 보여드릴 것입니다.
+
+
+# gRPC 실행하기
+
+
+# 참고 자료
+
+- https://aws.amazon.com/ko/compare/the-difference-between-grpc-and-rest/
@@ -0,0 +1,146 @@
+# Go 언어와 JSON 다루기
+
+Go 언어에서 JSON 데이터를 다루는 방법을 배워봅시다.
+
+Go 표준 라이브러리에는 JSON 데이터를 처리하기 위한 `encoding/json` 패키지가 포함되어 있습니다. Go는 구조체 태그(Struct Tag)를 사용하여 Go 구조체와 JSON 필드를 손쉽게 매핑할 수 있는 기능을 제공합니다. 이 태그는 Go 구조체를 JSON으로 변환하거나, JSON을 Go 구조체로 변환하는 과정을 제어합니다. 이 과정을 각각 Marshaling과 Unmarshaling이라고 부릅니다.
+
+## `Marshal()`과 `Unmarshal()` 이해하기
+
+**Marshaling**과 **Unmarshaling**은 Go 구조체로 JSON 데이터를 다룰 때 핵심적인 과정입니다.
+
+-   **Marshaling**: Go 구조체(메모리 상의 데이터)를 JSON 문자열(텍스트 데이터)로 변환하는 과정입니다. 주로 API 응답으로 JSON을 보내거나, 데이터를 파일로 저장할 때 사용됩니다.
+-   **Unmarshaling**: JSON 문자열을 Go 구조체로 변환하는 과정입니다. 주로 외부 API로부터 받은 JSON 데이터를 다루거나 파일에서 데이터를 읽어올 때 사용됩니다.
+
+> **가장 흔히 겪는 문제**: JSON과 Go 구조체 간 변환 시 가장 흔한 버그는 구조체의 필드명을 소문자로 시작하여 발생하는 문제입니다. `encoding/json` 패키지가 구조체의 필드에 접근하려면, 해당 필드는 **반드시 대문자로 시작해야 합니다 (Exported field)**. Marshaling 또는 Unmarshaling이 제대로 동작하지 않는다면, 가장 먼저 구조체 필드명이 대문자로 시작하는지 확인해 보세요.
+
+# 코딩 예제
+
+아래 `encodeDecode.go` 코드는 간단한 예제를 통해 JSON 레코드의 Marshaling과 Unmarshaling 과정을 보여줍니다.
+
+```go
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// UseAll 구조체는 JSON 데이터와 매핑됩니다.
+type UseAll struct {
+	Name    string `json:"username"`
+	Surname string `json:"surname"`
+	Year    int    `json:"created"`
+}
+```
+
+구조체 필드 옆의 `` `json:"..."` `` 부분을 **구조체 태그**라고 부릅니다. 이 태그는 각 필드가 JSON 데이터에서 어떤 키(key)와 매핑되는지를 명시합니다.
+- `Name` 필드는 JSON에서 `username` 키와 매핑됩니다.
+- `Surname` 필드는 `surname` 키와 매핑됩니다.
+- `Year` 필드는 `created` 키와 매핑됩니다.
+
+이 태그 정보는 Marshaling과 Unmarshaling 과정에서 사용되며, 이 외에는 `UseAll`을 일반적인 Go 구조체처럼 사용하면 됩니다.
+
+```go
+func main() {
+    // Marshaling할 구조체 인스턴스 생성
+	useall := UseAll{Name: "Mike", Surname: "Tsoukalos", Year: 2021}
+
+	// Go 구조체를 JSON 바이트 슬라이스로 Marshaling합니다.
+	t, err := json.Marshal(&useall)
+}
+```
+
+`json.Marshal()` 함수는 Go 데이터(주로 구조체 포인터)를 인자로 받아, JSON으로 인코딩된 `[]byte`와 `error`를 반환합니다.
+
+```go
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		// t는 []byte 타입이므로, 출력을 위해 문자열로 변환합니다.
+		fmt.Printf("Value %s\n", t)
+	}
+
+	// Unmarshaling할 JSON 문자열 데이터
+	str := `{"username": "M.", "surname": "Ts", "created":2020}`
+```
+
+JSON 데이터는 보통 문자열 형태로 다루어집니다.
+
+```go
+	// json.Unmarshal 함수는 바이트 슬라이스를 인자로 받으므로, 문자열을 변환합니다.
+	jsonRecord := []byte(str)
+```
+
+`json.Unmarshal()` 함수는 바이트 슬라이스 (`[]byte`)를 인자로 받기 때문에, 먼저 JSON 문자열을 `[]byte` 타입으로 변환해야 합니다.
+
+```go
+	// 변환된 JSON 데이터를 담을 구조체 변수를 선언합니다.
+	var temp UseAll
+	// JSON 바이트 슬라이스를 Go 구조체로 Unmarshaling합니다.
+	err = json.Unmarshal(jsonRecord, &temp)
+```
+
+`json.Unmarshal()` 함수는 JSON 데이터가 담긴 바이트 슬라이스와, 데이터를 채워 넣을 Go 구조체 변수의 **포인터**를 인자로 받습니다. 포인터를 사용하는 이유는 함수가 `temp` 변수의 값을 직접 수정해야 하기 때문입니다. 함수가 종료된 후에도 변경된 값이 유지되려면 이처럼 변수의 메모리 주소를 전달해야 합니다.
+
+```go
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Data type: %T with value %v\n", temp, temp)
+	}
+```
+
+`encodeDecode.go`를 실행하면 다음과 같은 결과가 출력됩니다.
+
+```bash
+# go run encodeDecode.go
+Value {"username":"Mike","surname":"Tsoukalos","created":2021}
+Data type: main.UseAll with value {M. Ts 2020}
+```
+
+---
+
+### 전체 예제 코드
+
+```go
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type UseAll struct {
+	Name    string `json:"username"`
+	Surname string `json:"surname"`
+	Year    int    `json:"created"`
+}
+
+func main() {
+	useall := UseAll{Name: "Mike", Surname: "Tsoukalos", Year: 2021}
+
+	// Marshaling: Go 구조체 -> JSON
+	t, err := json.Marshal(&useall)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Value %s\n", t)
+	}
+
+	// Unmarshaling할 JSON 문자열
+	str := `{"username": "M.", "surname": "Ts", "created":2020}`
+	jsonRecord := []byte(str)
+
+	// 결과를 저장할 구조체 변수
+	var temp UseAll
+	// Unmarshaling: JSON -> Go 구조체
+	err = json.Unmarshal(jsonRecord, &temp)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Data type: %T with value %v\n", temp, temp)
+	}
+}
+```
+
+
@@ -0,0 +1,129 @@
+# Working with JSON
+
+Let’s learn how to work with JSON data.
+
+The Go standard library includes `encoding/json`, which is for working with JSON data. Additionally, Go allows us to add support for JSON fields in Go structures using tags. Tags control the encoding and decoding of JSON records to and from Go structures. But first, we should talk about marshaling and unmarshaling JSON records.
+
+## Using `Marshal()` and `Unmarshal()`
+
+Both the marshaling and unmarshaling of JSON data are important procedures for working with JSON data using Go structures. **Marshaling** is the process of converting a Go structure into a JSON record. We usually want that for transferring JSON data via computer networks or for saving it on disk. **Unmarshaling** is the process of converting a JSON record given as a byte slice into a Go structure. We usually want that when receiving JSON data via computer networks or when loading JSON data from disk files.
+
+> **Note:** The number one bug when converting JSON records into Go structures and vice versa is not making the required fields of our Go structures exported. When we have issues with marshaling and unmarshaling, begin our debugging process from there.
+
+# Coding example
+
+The code in `encodeDecode.go` illustrates both the marshaling and unmarshaling of JSON records using hardcoded data for simplicity:
+
+```go
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type UseAll struct {
+	Name    string `json:"username"`
+	Surname string `json:"surname"`
+	Year    int    `json:"created"`
+}
+```
+
+What the previous metadata tells us is that the `Name` field of the `UseAll` structure is translated to `username` in the JSON record, and vice versa; the `Surname` field is translated to `surname`, and vice versa; and the `Year` structure field is translated to `created` in the JSON record, and vice versa. This information has to do with the marshaling and unmarshaling of JSON data. Other than this, we treat and use `UseAll` as a regular Go structure.
+
+```go
+func main() {
+  useall := UseAll{Name: "Mike", Surname: "Tsoukalos", Year: 2021}
+
+	// Regular Structure
+	// Encoding JSON data -> Convert Go Structure to JSON record with fields
+	t, err := json.Marshal(&useall)
+}
+```
+
+The `json.Marshal()` function requires a pointer to a structure variable—its real data type is an empty interface variable—and returns a byte slice with the encoded information and an `error` variable.
+
+```go
+if err != nil {
+  fmt.Println(err)
+} else {
+  fmt.Printf("Value %s\n", t)
+}
+
+// Decoding JSON data given as a string
+str := `{"username": "M.", "surname": "Ts", "created":2020}`
+```
+
+JSON data usually comes as a string.
+
+```go
+	// Convert string into a byte slice
+	jsonRecord := []byte(str)
+```
+
+However, as `json.Unmarshal()` requires a byte slice, we need to convert that string into a byte slice before passing it to `json.Unmarshal()`.
+
+```go
+	// Create a structure variable to store the result
+	temp := UseAll{}
+	err = json.Unmarshal(jsonRecord, &temp)
+```
+
+The `json.Unmarshal()` function requires the byte slice with the JSON record and a pointer to the Go structure variable that is going to store the JSON record and returns an `error` variable.
+
+```go
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Data type: %T with value %v\n", temp, temp)
+	}
+```
+
+Running `encodeDecode.go` produces the next output:
+
+```bash
+# go run encodeDecode.go
+Value {"username":"Mike","surname":"Tsoukalos","created":2021}
+Data type: main.UseAll with value {M. Ts 2020}
+```
+
+```go
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type UseAll struct {
+	Name    string `json:"username"`
+	Surname string `json:"surname"`
+	Year    int    `json:"created"`
+}
+
+func main() {
+	useall := UseAll{Name: "Mike", Surname: "Tsoukalos", Year: 2021}
+
+	// Regular Structure
+	// Encoding JSON data -> Convert Go Structure to JSON record with fields
+	t, err := json.Marshal(&useall)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Value %s\n", t)
+	}
+
+	// Decoding JSON data given as a string
+	str := `{"username": "M.", "surname": "Ts", "created":2020}`
+	// Convert string into a byte slice
+	jsonRecord := []byte(str)
+	// Create a structure variable to store the result
+	temp := UseAll{}
+	err = json.Unmarshal(jsonRecord, &temp)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Printf("Data type: %T with value %v\n", temp, temp)
+	}
+}
+```
@@ -0,0 +1,156 @@
+# 인터페이스 정의 언어(IDL) 파일 정의하기
+
+인터페이스 정의 언어(IDL) 파일을 정의하는 방법을 배워보겠습니다.
+
+우리가 개발할 gRPC 서비스는 다음 기능을 지원할 것입니다:
+
+-   서버는 클라이언트에게 현재 날짜와 시간을 반환해야 합니다.
+-   서버는 클라이언트에게 주어진 길이의 무작위로 생성된 비밀번호를 반환해야 합니다.
+-   서버는 클라이언트에게 무작위 정수를 반환해야 합니다.
+
+gRPC 클라이언트와 서버 개발을 시작하기 전에, IDL 파일을 먼저 정의해야 합니다. IDL 파일과 관련된 파일들을 관리하기 위해 별도의 GitHub 저장소가 필요하며, 여기서는 https://github.com/Educative-Content/protoapi 를 사용합니다.
+
+## IDL 파일의 구조
+
+다음은 `protoapi.proto`라는 IDL 파일의 내용입니다:
+
+```proto
+syntax = "proto3";
+```
+
+이 파일은 프로토콜 버퍼 언어의 **proto3** 버전을 사용합니다. 이전 버전인 **proto2**도 있으며, 약간의 문법적 차이가 있습니다. `proto3`를 명시하지 않으면, 프로토콜 버퍼 컴파일러는 **proto2**를 사용하는 것으로 간주합니다. 버전 정의는 `.proto` 파일의 첫 번째 비어있지 않은, 주석이 아닌 라인에 위치해야 합니다.
+
+```proto
+syntax = "proto3";
+
+option go_package = "./;protoapi";
+```
+
+gRPC 도구들은 이 `.proto` 파일로부터 Go 코드를 생성할 것입니다. 위 라인은 생성될 Go 패키지의 이름이 `protoapi`임을 명시합니다. `./`를 사용했기 때문에 출력 파일은 `protoapi.proto`와 동일한 현재 디렉토리에 생성됩니다.
+
+```proto
+service Random {
+    rpc GetDate (RequestDateTime) returns (DateTime);
+    rpc GetRandom (RandomParams) returns (RandomInt);
+    rpc GetRandomPass (RequestPass) returns (RandomPass);
+}
+```
+
+이 블록은 gRPC 서비스의 이름(`Random`)과 지원하는 메서드들을 명시합니다. 또한, 각 상호작용에 필요한 메시지들을 지정합니다. 예를 들어, `GetDate`의 경우 클라이언트는 `RequestDateTime` 메시지를 보내고 `DateTime` 메시지를 받기를 기대합니다.
+
+이 메시지들은 동일한 `.proto` 파일에 정의되어 있습니다.
+
+```proto
+// For random number
+```
+
+모든 `.proto` 파일은 C와 C++ 스타일의 주석을 지원합니다. 즉, `// text`와 `/* text */` 형식의 주석을 사용할 수 있습니다.
+
+```proto
+message RandomParams {
+    int64 Seed = 1;
+    int64 Place = 2;
+}
+```
+
+난수 생성기는 시드(seed) 값으로 시작하며, 이 값은 클라이언트가 지정하여 `RandomParams` 메시지를 통해 서버로 전송됩니다. `Place` 필드는 무작위로 생성된 정수 시퀀스에서 반환될 난수의 위치를 지정합니다.
+
+```proto
+message RandomInt {
+    int64 Value = 1;
+}
+```
+
+앞선 두 메시지는 `GetRandom` 메서드와 관련이 있습니다. `RandomParams`는 요청의 매개변수를 설정하는 데 사용되고, `RandomInt`는 서버가 생성한 난수를 저장하는 데 사용됩니다. 모든 메시지 필드는 `int64` 데이터 타입을 가집니다.
+
+```proto
+message DateTime {
+    string Value = 1;
+}
+
+message RequestDateTime {
+    string Value = 2;
+}
+```
+
+위 두 메시지는 `GetDate` 메서드의 동작을 지원하기 위한 것입니다. `RequestDateTime` 메시지는 실질적인 데이터를 담고 있지 않은 더미 메시지입니다. 단지 클라이언트가 서버로 보내는 메시지가 필요할 뿐이며, `Value` 필드에는 어떤 종류의 정보든 저장할 수 있습니다. 서버가 반환하는 정보는 `DateTime` 메시지에 `string` 값으로 저장됩니다.
+
+```proto
+// For random password
+message RequestPass {
+    int64 Seed = 1;
+    int64 Length = 8;
+}
+
+message RandomPass {
+    string Password = 1;
+}
+```
+
+마지막으로, 위 두 메시지는 `GetRandomPass`의 동작을 위한 것입니다.
+
+요약하자면, IDL 파일은 다음을 수행합니다:
+-   `proto3`를 사용함을 명시합니다.
+-   서비스의 이름이 `Random`임을 정의합니다.
+-   생성될 Go 패키지의 이름이 `protoapi`임을 명시합니다.
+-   gRPC 서비스가 `GetDate`, `GetRandom`, `GetRandomPass` 세 가지 메서드를 지원함을 정의하고, 이 메서드 호출에서 교환될 메시지들의 이름을 정의합니다.
+-   데이터 교환에 사용될 여섯 가지 메시지의 형식을 정의합니다.
+
+## Go에서 IDL 파일 사용하기
+
+다음 중요한 단계는 이 파일을 Go에서 사용할 수 있는 형식으로 변환하는 것입니다. `protoapi.proto`나 다른 `.proto` 파일을 처리하여 관련된 Go `.pb.go` 파일을 생성하기 위해 몇 가지 추가 도구를 다운로드해야 합니다. 프로토콜 버퍼 컴파일러 바이너리의 이름은 `protoc`입니다. macOS에서는 `brew install protobuf` 명령을 사용하여 `protoc`를 설치해야 합니다. 마찬가지로, Homebrew를 사용하여 `protoc-gen-go-grpc`와 `protoc-gen-go` 패키지도 설치해야 합니다. 이 두 패키지는 Go와 관련이 있습니다.
+
+Linux에서는 선호하는 패키지 관리자를 사용하여 `protobuf`를 설치하고, `go install github.com/golang/protobuf/protoc-gen-go@latest` 명령을 사용하여 `protoc-gen-go`를 설치해야 합니다. 마찬가지로, `go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest`를 실행하여 `protoc-gen-go-grpc` 실행 파일을 설치해야 합니다.
+
+> 참고: Go 1.16부터는 모듈 모드에서 패키지를 빌드하고 설치하는 데 `go install`을 사용하는 것이 권장됩니다. `go get`의 사용은 더 이상 사용되지 않습니다. `go install`을 사용할 때는 최신 버전을 설치하기 위해 패키지 이름 뒤에 `@latest`를 추가하는 것을 잊지 마세요.
+
+- protoc
+- protoc-gen-go
+- protoc-gen-go-grpc
+
+변환 과정은 다음 단계를 필요로 합니다:
+
+```bash
+protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. \
+--go-grpc_opt=paths=source_relative protoapi.proto
+```
+
+이 명령을 실행하면, GitHub 저장소의 루트 디렉토리에 `protoapi_grpc.pb.go`와 `protoapi.pb.go`라는 두 개의 파일이 생성됩니다. `protoapi.pb.go` 소스 코드 파일에는 메시지가 포함되어 있고, `protoapi_grpc.pb.go`에는 서비스가 포함되어 있습니다.
+
+`protoapi_grpc.pb.go`의 첫 열 줄은 다음과 같습니다:
+
+```go
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+
+package protoapi
+```
+
+앞서 논의했듯이, 패키지 이름은 `protoapi`입니다.
+
+```go
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+
+codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+```
+
+이것은 `import` 블록입니다. `context "context"`가 있는 이유는 `context`가 예전에는 표준 Go 라이브러리의 일부가 아닌 외부 Go 패키지였기 때문입니다.
+
+`protoapi.pb.go`의 첫 줄은 다음과 같습니다:
+
+```go
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.27.1
+// 	protoc        v3.17.3
+// source: protoapi.proto
+
+package protoapi
+```
+
+`protoapi_grpc.pb.go`와 `protoapi.pb.go`는 모두 `protoapi` Go 패키지의 일부이므로, 코드에서 한 번만 포함하면 됩니다.
+
+```
@@ -0,0 +1,80 @@
+package entity
+
+import (
+	"context"
+	"fmt"
+	"grpccanary/protoapi"
+	"math/rand"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+func AskingDateTime(ctx context.Context, m protoapi.RandomClient) (*protoapi.DateTime, error) {
+	request := &protoapi.RequestDateTime{
+		Value: "Please send me the date and time",
+	}
+
+	return m.GetDate(ctx, request)
+}
+
+func AskPass(ctx context.Context, m protoapi.RandomClient, seed int64, length int64) (*protoapi.RandomPass, error) {
+	request := &protoapi.RequestPass{
+		Seed:   seed,
+		Length: length,
+	}
+
+	return m.GetRandomPass(ctx, request)
+}
+
+func AskRandom(ctx context.Context, m protoapi.RandomClient, seed int64, place int64) (*protoapi.RandomInt, error) {
+	request := &protoapi.RandomParams{
+		Seed:  seed,
+		Place: place,
+	}
+
+	return m.GetRandom(ctx, request)
+}
+
+func ClientRun(addr string) {
+	conn, err := grpc.Dial(addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		fmt.Println("Dial:", err)
+		return
+	}
+
+	rand.Seed(time.Now().Unix())
+	seed := int64(rand.Intn(100))
+
+	client := protoapi.NewRandomClient(conn)
+	r, err := AskingDateTime(context.Background(), client)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("Server Date and Time:", r.Value)
+
+	length := int64(rand.Intn(20))
+	p, err := AskPass(context.Background(), client, 100, length+1)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("Random Password:", p.Password)
+
+	place := int64(rand.Intn(100))
+	i, err := AskRandom(context.Background(), client, seed, place)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("Random Integer 1:", i.Value)
+
+	k, err := AskRandom(context.Background(), client, seed, place-1)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println("Random Integer 2:", k.Value)
+}
@@ -0,0 +1,111 @@
+package entity
+
+import (
+	"context"
+	"fmt"
+	"grpccanary/protoapi"
+	"math/rand"
+	"net"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/reflection"
+)
+
+var min = 0
+var max = 100
+var port = ":8080"
+
+func random(min, max int, src rand.Source) int {
+	return rand.New(src).Intn(max-min) + min
+}
+
+// Extra function for creating secure random numbers
+//
+// func randomSecure(min, max int) int {
+// 	v, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
+// 	if err != nil {
+// 		fmt.Println(err)
+// 		return min
+// 	}
+// 	fmt.Println("**", v, min, max)
+
+// 	return min + int(v.Uint64())
+// }
+
+func getString(len int64) string {
+	temp := ""
+	startChar := "!"
+	var i int64 = 1
+	for {
+		// For getting valid ASCII characters
+		myRand := random(0, 94, rand.NewSource(time.Now().UnixNano()))
+		newChar := string(startChar[0] + byte(myRand))
+		temp = temp + newChar
+		if i == len {
+			break
+		}
+		i++
+	}
+	return temp
+}
+
+type RandomServer struct {
+	protoapi.UnimplementedRandomServer
+}
+
+func (RandomServer) GetDate(ctx context.Context, r *protoapi.RequestDateTime) (*protoapi.DateTime, error) {
+	currentTime := time.Now()
+	response := &protoapi.DateTime{
+		Value: currentTime.String(),
+	}
+
+	return response, nil
+}
+
+func (RandomServer) GetRandom(ctx context.Context, r *protoapi.RandomParams) (*protoapi.RandomInt, error) {
+	src := rand.NewSource(r.GetSeed())
+	place := r.GetPlace()
+	temp := random(min, max, src)
+	for {
+		place--
+		if place <= 0 {
+			break
+		}
+		temp = random(min, max, src)
+	}
+
+	response := &protoapi.RandomInt{
+		Value: int64(temp),
+	}
+
+	return response, nil
+}
+
+func (RandomServer) GetRandomPass(ctx context.Context, r *protoapi.RequestPass) (*protoapi.RandomPass, error) {
+	rand.Seed(r.GetSeed())
+	temp := getString(r.GetLength())
+
+	response := &protoapi.RandomPass{
+		Password: temp,
+	}
+
+	return response, nil
+}
+
+func ServerRun(addr string) {
+	server := grpc.NewServer()
+	var randomServer RandomServer
+	protoapi.RegisterRandomServer(server, randomServer)
+
+	reflection.Register(server)
+
+	listen, err := net.Listen("tcp", port)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Println("Serving requests...")
+	server.Serve(listen)
+}
@@ -0,0 +1 @@
+package httpentity
@@ -0,0 +1,83 @@
+package httpentity
+
+// import (
+// 	"encoding/json"
+// 	"log"
+// 	"net/http"
+// 	"strings"
+
+// 	"github.com/gin-gonic/gin"
+// )
+
+// func NewWebServer(addr string) *http.Server {
+// 	srv := &http.Server{
+// 		Addr:    addr,
+// 		Handler: createRouter(),
+// 	}
+
+// 	return srv
+// }
+
+// func createRouter() *gin.Engine {
+// 	// Create a new gin router for api
+// 	// What is difference between gin.Default() and gin.New()?
+// 	// https://stackoverflow.com/questions/44318441/what-is-difference-between-gin-default-and-gin-new
+
+// 	apiEngine := gin.New()
+// 	apiGroup := apiEngine.Group("/api")
+// 	{
+// 		apiGroup.GET("/randomNumber", GET_RandomNumber)
+// 		apiGroup.GET("/randomPassword", GET_RandomPassword)
+// 		apiGroup.GET("/randomDate", GET_RandomDate)
+// 	}
+
+// 	// create a new gin router for static files
+// 	staticEngine := gin.New()
+// 	staticEngine.Static("/", "./web")
+
+// 	// Create a new gin router
+// 	r := gin.Default()
+// 	// r can accept all messages from apiEngine and staticEngine
+// 	r.Any("/*any", func(c *gin.Context) {
+// 		defer handleError(c)
+// 		w := c.Writer
+// 		w.Header().Set("Access-Control-Allow-Origin", "*")
+// 		w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE")
+
+// 		path := c.Param("any")
+
+// 		if strings.HasPrefix(path, "/api") {
+// 			apiEngine.ServeHTTP(c.Writer, c.Request)
+// 		} else {
+// 			staticEngine.HandleContext(c)
+// 		}
+
+// 	})
+
+// 	// Return the router
+// 	return r
+// }
+
+// func GET_RandomNumber(c *gin.Context) {
+
+// 	// make a json decoder
+// 	dec := json.NewDecoder(c.Request.Body)
+// 	obj := map[string]interface{}{}
+// 	dec.Decode(&obj)
+
+// 	seed := obj["seed"]
+// 	place := obj["place"]
+
+// 	response := map[string]interface{}{
+// 		"value": 10,
+// 	}
+
+// 	c.JSON(http.StatusOK)
+// }
+
+// func handleError(c *gin.Context) {
+// 	if r := recover(); r != nil {
+// 		log.Println(r)
+// 		c.String(http.StatusBadRequest, r.(error).Error())
+// 	}
+// }
@@ -0,0 +1,62 @@
+package jsonexample
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type Person struct {
+	Name    string   `json:"name"`
+	Age     int      `json:"age"`
+	History []string `json:"history"`
+}
+
+func JsonParsingExample() {
+	obj := map[string]interface{}{
+		"name": "홍길동",
+		"age":  623,
+		"history": []string{
+			"1900-양반집을 털었다",
+			"1910-왕에게 잡혀감",
+		},
+	}
+
+	b, err := json.Marshal(obj)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(string(b))
+
+	obj2 := map[string]interface{}{}
+	err = json.Unmarshal(b, &obj2)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(obj2["age"])
+
+	p := Person{
+		Name: "Godopu2",
+		Age:  70,
+		History: []string{
+			"1900-양반집을 털었다",
+			"1910-왕에게 잡혀감",
+		},
+	}
+	b, err = json.Marshal(&p)
+
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(string(b))
+
+	var p2 Person
+	err = json.Unmarshal(b, &p2)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(p2.Age)
+}
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	entity "grpccanary/examples/grpcentity"
+	"grpccanary/examples/jsonexample"
+	"time"
+)
+
+var port = ":8080"
+
+func main() {
+	jsonexample.JsonParsingExample()
+}
+
+func grpcSample() {
+	go entity.ServerRun(port)
+
+	// Just to be sure that the server is running
+	time.Sleep(1 * time.Second)
+
+	fmt.Println("Client:")
+	entity.ClientRun("localhost" + port)
+}
@@ -0,0 +1,43 @@
+module grpccanary
+
+go 1.25.4
+
+require (
+	github.com/gin-gonic/gin v1.11.0
+	google.golang.org/grpc v1.76.0
+	google.golang.org/protobuf v1.36.10
+)
+
+require (
+	github.com/bytedance/sonic v1.14.0 // indirect
+	github.com/bytedance/sonic/loader v0.3.0 // indirect
+	github.com/cloudwego/base64x v0.1.6 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.8 // indirect
+	github.com/gin-contrib/sse v1.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.27.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/goccy/go-yaml v1.18.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.54.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.3.0 // indirect
+	go.uber.org/mock v0.5.0 // indirect
+	golang.org/x/arch v0.20.0 // indirect
+	golang.org/x/crypto v0.40.0 // indirect
+	golang.org/x/mod v0.25.0 // indirect
+	golang.org/x/net v0.42.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/text v0.27.0 // indirect
+	golang.org/x/tools v0.34.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b // indirect
+)
@@ -0,0 +1,114 @@
+github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
+github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
+github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
+github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
+github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
+github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
+github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
+github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
+github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
+github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
+github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
+github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
+github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
+github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
+github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
+go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc=
+go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
+go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
+golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
+golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
+golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
+golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs=
+golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
+golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
+golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b h1:zPKJod4w6F1+nRGDI9ubnXYhU9NSWoFAijkHkUXeTK8=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250804133106-a7a43d27e69b/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -0,0 +1,12 @@
+{
+  "name": "홍길동",
+  "age": 623,
+  "history": [
+    "1900-양반집을 털었다",
+    "1910-왕에게 잡혀감"
+  ],
+  "child": {
+    "name": "홍길순",
+    "age": 599
+  }
+}
@@ -0,0 +1,38 @@
+syntax = "proto3";
+
+option go_package = "./protoapi/;protoapi";
+
+service Random {
+    rpc GetDate (RequestDateTime) returns (DateTime);
+    rpc GetRandom (RandomParams) returns (RandomInt);
+    rpc GetRandomPass (RequestPass) returns (RandomPass);
+}
+
+// For random number
+message RandomParams {
+    int64 Seed = 1;
+    int64 Place = 2;
+}
+
+message RandomInt {
+    int64 Value = 1;
+}
+
+// For date time
+message DateTime {
+    string Value = 1;
+}
+
+message RequestDateTime {
+    string Value = 2;
+}
+
+// For random password
+message RequestPass {
+    int64 Seed = 1;
+    int64 Length = 8;
+}
+
+message RandomPass {
+    string Password = 1;
+}
@@ -0,0 +1,490 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.33.0
+// 	protoc        v3.21.12
+// source: protoapi.proto
+
+package protoapi
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+// For random number
+type RandomParams struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Seed  int64 `protobuf:"varint,1,opt,name=Seed,proto3" json:"Seed,omitempty"`
+	Place int64 `protobuf:"varint,2,opt,name=Place,proto3" json:"Place,omitempty"`
+}
+
+func (x *RandomParams) Reset() {
+	*x = RandomParams{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RandomParams) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RandomParams) ProtoMessage() {}
+
+func (x *RandomParams) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RandomParams.ProtoReflect.Descriptor instead.
+func (*RandomParams) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *RandomParams) GetSeed() int64 {
+	if x != nil {
+		return x.Seed
+	}
+	return 0
+}
+
+func (x *RandomParams) GetPlace() int64 {
+	if x != nil {
+		return x.Place
+	}
+	return 0
+}
+
+type RandomInt struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Value int64 `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"`
+}
+
+func (x *RandomInt) Reset() {
+	*x = RandomInt{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RandomInt) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RandomInt) ProtoMessage() {}
+
+func (x *RandomInt) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RandomInt.ProtoReflect.Descriptor instead.
+func (*RandomInt) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *RandomInt) GetValue() int64 {
+	if x != nil {
+		return x.Value
+	}
+	return 0
+}
+
+// For date time
+type DateTime struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Value string `protobuf:"bytes,1,opt,name=Value,proto3" json:"Value,omitempty"`
+}
+
+func (x *DateTime) Reset() {
+	*x = DateTime{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[2]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DateTime) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DateTime) ProtoMessage() {}
+
+func (x *DateTime) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[2]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DateTime.ProtoReflect.Descriptor instead.
+func (*DateTime) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{2}
+}
+
+func (x *DateTime) GetValue() string {
+	if x != nil {
+		return x.Value
+	}
+	return ""
+}
+
+type RequestDateTime struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Value string `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
+}
+
+func (x *RequestDateTime) Reset() {
+	*x = RequestDateTime{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RequestDateTime) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RequestDateTime) ProtoMessage() {}
+
+func (x *RequestDateTime) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[3]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RequestDateTime.ProtoReflect.Descriptor instead.
+func (*RequestDateTime) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *RequestDateTime) GetValue() string {
+	if x != nil {
+		return x.Value
+	}
+	return ""
+}
+
+// For random password
+type RequestPass struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Seed   int64 `protobuf:"varint,1,opt,name=Seed,proto3" json:"Seed,omitempty"`
+	Length int64 `protobuf:"varint,8,opt,name=Length,proto3" json:"Length,omitempty"`
+}
+
+func (x *RequestPass) Reset() {
+	*x = RequestPass{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[4]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RequestPass) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RequestPass) ProtoMessage() {}
+
+func (x *RequestPass) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[4]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RequestPass.ProtoReflect.Descriptor instead.
+func (*RequestPass) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *RequestPass) GetSeed() int64 {
+	if x != nil {
+		return x.Seed
+	}
+	return 0
+}
+
+func (x *RequestPass) GetLength() int64 {
+	if x != nil {
+		return x.Length
+	}
+	return 0
+}
+
+type RandomPass struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Password string `protobuf:"bytes,1,opt,name=Password,proto3" json:"Password,omitempty"`
+}
+
+func (x *RandomPass) Reset() {
+	*x = RandomPass{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_protoapi_proto_msgTypes[5]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *RandomPass) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*RandomPass) ProtoMessage() {}
+
+func (x *RandomPass) ProtoReflect() protoreflect.Message {
+	mi := &file_protoapi_proto_msgTypes[5]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use RandomPass.ProtoReflect.Descriptor instead.
+func (*RandomPass) Descriptor() ([]byte, []int) {
+	return file_protoapi_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *RandomPass) GetPassword() string {
+	if x != nil {
+		return x.Password
+	}
+	return ""
+}
+
+var File_protoapi_proto protoreflect.FileDescriptor
+
+var file_protoapi_proto_rawDesc = []byte{
+	0x0a, 0x0e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x61, 0x70, 0x69, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x22, 0x38, 0x0a, 0x0c, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73,
+	0x12, 0x12, 0x0a, 0x04, 0x53, 0x65, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04,
+	0x53, 0x65, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x03, 0x52, 0x05, 0x50, 0x6c, 0x61, 0x63, 0x65, 0x22, 0x21, 0x0a, 0x09, 0x52, 0x61,
+	0x6e, 0x64, 0x6f, 0x6d, 0x49, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x20, 0x0a,
+	0x08, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x56, 0x61, 0x6c,
+	0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22,
+	0x27, 0x0a, 0x0f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69,
+	0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x39, 0x0a, 0x0b, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x50, 0x61, 0x73, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x53, 0x65, 0x65, 0x64, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x53, 0x65, 0x65, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x4c,
+	0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x4c, 0x65, 0x6e,
+	0x67, 0x74, 0x68, 0x22, 0x28, 0x0a, 0x0a, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x50, 0x61, 0x73,
+	0x73, 0x12, 0x1a, 0x0a, 0x08, 0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x50, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64, 0x32, 0x84, 0x01,
+	0x0a, 0x06, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x12, 0x26, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x44,
+	0x61, 0x74, 0x65, 0x12, 0x10, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74,
+	0x65, 0x54, 0x69, 0x6d, 0x65, 0x1a, 0x09, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x54, 0x69, 0x6d, 0x65,
+	0x12, 0x26, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x12, 0x0d, 0x2e,
+	0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x73, 0x1a, 0x0a, 0x2e, 0x52,
+	0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x49, 0x6e, 0x74, 0x12, 0x2a, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x52,
+	0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x50, 0x61, 0x73, 0x73, 0x12, 0x0c, 0x2e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x50, 0x61, 0x73, 0x73, 0x1a, 0x0b, 0x2e, 0x52, 0x61, 0x6e, 0x64, 0x6f, 0x6d,
+	0x50, 0x61, 0x73, 0x73, 0x42, 0x16, 0x5a, 0x14, 0x2e, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x61,
+	0x70, 0x69, 0x2f, 0x3b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x61, 0x70, 0x69, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_protoapi_proto_rawDescOnce sync.Once
+	file_protoapi_proto_rawDescData = file_protoapi_proto_rawDesc
+)
+
+func file_protoapi_proto_rawDescGZIP() []byte {
+	file_protoapi_proto_rawDescOnce.Do(func() {
+		file_protoapi_proto_rawDescData = protoimpl.X.CompressGZIP(file_protoapi_proto_rawDescData)
+	})
+	return file_protoapi_proto_rawDescData
+}
+
+var file_protoapi_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_protoapi_proto_goTypes = []interface{}{
+	(*RandomParams)(nil),    // 0: RandomParams
+	(*RandomInt)(nil),       // 1: RandomInt
+	(*DateTime)(nil),        // 2: DateTime
+	(*RequestDateTime)(nil), // 3: RequestDateTime
+	(*RequestPass)(nil),     // 4: RequestPass
+	(*RandomPass)(nil),      // 5: RandomPass
+}
+var file_protoapi_proto_depIdxs = []int32{
+	3, // 0: Random.GetDate:input_type -> RequestDateTime
+	0, // 1: Random.GetRandom:input_type -> RandomParams
+	4, // 2: Random.GetRandomPass:input_type -> RequestPass
+	2, // 3: Random.GetDate:output_type -> DateTime
+	1, // 4: Random.GetRandom:output_type -> RandomInt
+	5, // 5: Random.GetRandomPass:output_type -> RandomPass
+	3, // [3:6] is the sub-list for method output_type
+	0, // [0:3] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_protoapi_proto_init() }
+func file_protoapi_proto_init() {
+	if File_protoapi_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_protoapi_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RandomParams); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_protoapi_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RandomInt); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_protoapi_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DateTime); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_protoapi_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RequestDateTime); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_protoapi_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RequestPass); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_protoapi_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*RandomPass); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_protoapi_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   6,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_protoapi_proto_goTypes,
+		DependencyIndexes: file_protoapi_proto_depIdxs,
+		MessageInfos:      file_protoapi_proto_msgTypes,
+	}.Build()
+	File_protoapi_proto = out.File
+	file_protoapi_proto_rawDesc = nil
+	file_protoapi_proto_goTypes = nil
+	file_protoapi_proto_depIdxs = nil
+}
@@ -0,0 +1,197 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v3.21.12
+// source: protoapi.proto
+
+package protoapi
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Random_GetDate_FullMethodName       = "/Random/GetDate"
+	Random_GetRandom_FullMethodName     = "/Random/GetRandom"
+	Random_GetRandomPass_FullMethodName = "/Random/GetRandomPass"
+)
+
+// RandomClient is the client API for Random service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type RandomClient interface {
+	GetDate(ctx context.Context, in *RequestDateTime, opts ...grpc.CallOption) (*DateTime, error)
+	GetRandom(ctx context.Context, in *RandomParams, opts ...grpc.CallOption) (*RandomInt, error)
+	GetRandomPass(ctx context.Context, in *RequestPass, opts ...grpc.CallOption) (*RandomPass, error)
+}
+
+type randomClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewRandomClient(cc grpc.ClientConnInterface) RandomClient {
+	return &randomClient{cc}
+}
+
+func (c *randomClient) GetDate(ctx context.Context, in *RequestDateTime, opts ...grpc.CallOption) (*DateTime, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(DateTime)
+	err := c.cc.Invoke(ctx, Random_GetDate_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *randomClient) GetRandom(ctx context.Context, in *RandomParams, opts ...grpc.CallOption) (*RandomInt, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(RandomInt)
+	err := c.cc.Invoke(ctx, Random_GetRandom_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *randomClient) GetRandomPass(ctx context.Context, in *RequestPass, opts ...grpc.CallOption) (*RandomPass, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(RandomPass)
+	err := c.cc.Invoke(ctx, Random_GetRandomPass_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// RandomServer is the server API for Random service.
+// All implementations must embed UnimplementedRandomServer
+// for forward compatibility.
+type RandomServer interface {
+	GetDate(context.Context, *RequestDateTime) (*DateTime, error)
+	GetRandom(context.Context, *RandomParams) (*RandomInt, error)
+	GetRandomPass(context.Context, *RequestPass) (*RandomPass, error)
+	mustEmbedUnimplementedRandomServer()
+}
+
+// UnimplementedRandomServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedRandomServer struct{}
+
+func (UnimplementedRandomServer) GetDate(context.Context, *RequestDateTime) (*DateTime, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetDate not implemented")
+}
+func (UnimplementedRandomServer) GetRandom(context.Context, *RandomParams) (*RandomInt, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetRandom not implemented")
+}
+func (UnimplementedRandomServer) GetRandomPass(context.Context, *RequestPass) (*RandomPass, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetRandomPass not implemented")
+}
+func (UnimplementedRandomServer) mustEmbedUnimplementedRandomServer() {}
+func (UnimplementedRandomServer) testEmbeddedByValue()                {}
+
+// UnsafeRandomServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to RandomServer will
+// result in compilation errors.
+type UnsafeRandomServer interface {
+	mustEmbedUnimplementedRandomServer()
+}
+
+func RegisterRandomServer(s grpc.ServiceRegistrar, srv RandomServer) {
+	// If the following call pancis, it indicates UnimplementedRandomServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Random_ServiceDesc, srv)
+}
+
+func _Random_GetDate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestDateTime)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RandomServer).GetDate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Random_GetDate_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RandomServer).GetDate(ctx, req.(*RequestDateTime))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Random_GetRandom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RandomParams)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RandomServer).GetRandom(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Random_GetRandom_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RandomServer).GetRandom(ctx, req.(*RandomParams))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Random_GetRandomPass_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RequestPass)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(RandomServer).GetRandomPass(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Random_GetRandomPass_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(RandomServer).GetRandomPass(ctx, req.(*RequestPass))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Random_ServiceDesc is the grpc.ServiceDesc for Random service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Random_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "Random",
+	HandlerType: (*RandomServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "GetDate",
+			Handler:    _Random_GetDate_Handler,
+		},
+		{
+			MethodName: "GetRandom",
+			Handler:    _Random_GetRandom_Handler,
+		},
+		{
+			MethodName: "GetRandomPass",
+			Handler:    _Random_GetRandomPass_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "protoapi.proto",
+}
				`@@ -0,0 +1 @@`
				`GEMINI_API_KEY="AIzaSyB3yPk3Uljj-tLlANaJg3YVL1st6yqxCaA"`