go - shungo blog

【Go】 import cycle not allowed (循環参照)について

しゅんご — Thu, 23 Feb 2023 13:57:43 +0000

import cycle not allowed (循環参照とは？)
循環参照が起こるコード例
main.goを実行してみる
循環参照の対策方法

import cycle not allowed (循環参照とは？)

他のpackageにimportしたときに、こんなエラーが出た人はいるんではないでしょうか？

import cycle not allowed

このエラーは循環参照が起きているときの吐かれるエラーです。

たとえばpackage aとbがあった場合に、

package aでbの関数やメソッドを参照している
package bでもaの関数やメソッドを参照している

と循環参照していることになり、import cycle not allowedというエラーが出てしまいます。

循環参照が起こるコード例

循環参照が発生する具体的なコードを書いてみます。

ファイル構成

./app
├─ a/a.go
├─ b/b.go
├─ main.go
└─ go.mod

go.mod

module app

go 1.19

main.go

package main

import (
  "app/a"
)

func main() {
  a.CallB()
}

a.go

package a

import (
  "fmt"
  "app/b"
)

func PrintA() {
  fmt.Println("A")
}

func CallB() {
  b.PrintB()
}

b.go

package b

import (
  "fmt"
  "app/a"
)

func PrintB() {
  fmt.Println("B")
}

func CallA() {
  a.PrintA()
}

main.goを実行してみる

この状態でmain.goを実行するとimport cycle not allowedのエラーが出ます。

% go run main.go
package command-line-arguments
        imports app/a
        imports app/b
        imports app/a: import cycle not allowed

循環参照の対策方法

循環参照が起きないようにするには主に下記の方法があるようです。

ファイル構成を変更する
interfaceを使う
同じpackageにまとめる

それぞれの具体的な実装例はまた別の記事で紹介しようと思います。

The post 【Go】 import cycle not allowed (循環参照)について first appeared on shungo blog.

【Docker】 Go × Mailhog × net/smtpでメール送信する

しゅんご — Wed, 22 Feb 2023 14:11:45 +0000

はじめに
コード
メール送信
1. コンテナに入りmain.goを実行
2. mailhogで送信されたメールを確認

はじめに

Docker環境で構築したGoからメール送信する方法をご紹介します。

メールサーバーには、開発環境でメール送信を確認できるmailhogを使用します。

メール送信には標準パッケージのnet/smtpを用います。

今回の実装以外にもいろいろ追加していますが、

下記でメール送信を実装しているので参考にしてみてください！

GitHub - shungo0525/doker_go

Contribute to shungo0525/doker_go development by creating an account on GitHub.

コード

ファイル構成

./root_dir
├─ app
│   ├─ main.go
│   ├─ go.mod
│   └─ go.sum
├─ docker-compose.yml
└─ Dockerfile

Dockerfile

とりあえずGoが使える環境を構築します。

FROM golang:1.19-alpine

RUN apk update && apk add git

# appディレクトリの作成
RUN mkdir /go/src/app
# ワーキングディレクトリの設定
WORKDIR /go/src/app

docker-compose.yml

開発環境用のメールサーバーであるmailhogを使用します。

service名のmailhogとSMPTポートである1025はメール送信するときに指定します。

version: '3'
services:
  app:
    build: .
    tty: true
    volumes:
      - ./app:/go/src/app
    depends_on:
      - mysql
    ports:
      - 8000:8000

  mailhog:
    image: mailhog/mailhog:latest
    ports:
      - "8025:8025" # MailhogのWebとAPI用のポート
      - "1025:1025" # SMTPポート

main.go

docker-compose.ymlで指定したservice名のmailhogをhostnameに、portを1025に指定します。

docker-compose.ymlの値とここで指定する値が異なるとメール送信できないので注意しましょう。

送信元、送信先、メッセージ内容は必要に応じて変更してください。

package main

import (
  "fmt"
  "net/smtp"
  "os"
  "strings"
)

var (
  hostname = "mailhog" // docker-composeで指定したサービス名
  port     = 1025 // mailhogのSMPTポート
  username = "user@example.com"
  password = "password"
  from     = "from@example.net"
  subject  = "hello"
  body     = "Hello World!"
  receiver = []string{"receiver@example.com"}
)

func main() {
  SendEmail()
}

func SendEmail() {
  smtpServer := fmt.Sprintf("%s:%d", hostname, port)
  auth := smtp.CRAMMD5Auth(username, password)
  msg := []byte(fmt.Sprintf("To: %s\nSubject: %s\n\n%s", strings.Join(receiver, ","), subject, body))

  if err := smtp.SendMail(smtpServer, auth, from, receiver, msg); err != nil {
    fmt.Fprintln(os.Stderr, err)
  }
}

メール送信

コンテナに入りmain.goを実行

コンテナに入ってmain.goを実行することで、SendEmail()が実行されメール送信されます。

% dc exec app sh
# go run main.go

mailhogで送信されたメールを確認

http://localhost:8025/を開くとMailhogでローカル環境で送信したメールを確認することができます。

クリックすると送信内容の詳細を確認することができます。

The post 【Docker】 Go × Mailhog × net/smtpでメール送信する first appeared on shungo blog.

Docker × Go で gRPC を動かしてみた

しゅんご — Mon, 13 Feb 2023 13:05:14 +0000

はじめに
ローカル環境で実行する場合
Docker環境で実行する場合

はじめに

この記事ではgo × gRPCで簡単なリクエスト送信・レスポンスの表示を説明していきます。

大きく分けて、下記の3つを順番に実行していきます。

protoファイルからコードを自動生成
goでgRPCサーバーを起動
goでクライアントを実行してリクエスト送信・レスポンス表示

最初はローカルで実行して、次に同じことをDocker環境でも実行します。

この記事を書くにあたり、下記を参考にさせていただきました。

参考: 作ってわかる！はじめてのgRPC

今回実装したリポジトリです。

全体のコードはこちらをご覧くだしさい。

GitHub - shungo0525/grpc

Contribute to shungo0525/grpc development by creating an account on GitHub.

ローカル環境で実行する場合

パッケージインストール

まずは必要なパッケージをインストールします。

$ brew install protobuf
$ go get -u google.golang.org/grpc
$ go get -u google.golang.org/grpc/cmd/protoc-gen-go-grpc

パッケージの依存関係を管理するためのgo.modファイルを生成します。

$ cd study_grpc # 作業ディレクトリ
$ go mod init mygrpc

ディレクトリ構成

今回は下記のようなディレクトリ構成にしました。

./study_grpc # 作業ルートディレクトリ
├─ api
│   └─ hello.proto # protoファイル
├─ cmd
│   ├─ server
│   │ └─ main.go
│   └─ client
│        └─ main.go
├─ pkg
│   └─ grpc # ここにコードを自動生成させる
│         ├─ hello.pb.go
│         └─ hello_grpc.pb.go
├─ go.mod
└─ go.sum

protoファイル作成

api/hello.proto

// protoのバージョンの宣言
syntax= "proto3";

// protoファイルから自動生成させるGoのコードの置き先
// (詳細は4章にて)
option go_package = "pkg/grpc";

// packageの宣言
package myapp;

// サービスの定義
service GreetingService {
   // サービスが持つメソッドの定義
  rpc Hello (HelloRequest) returns (HelloResponse);
}

// 型の定義
message HelloRequest {
   stringname = 1;
}

message HelloResponse {
   stringmessage = 1;
}

protocコマンドでコードを自動生成

下記のコマンドを実行するとpkg/grpcディレクトリ直下に、2つのファイルが生成されます。

$  cd api
$ protoc --go_out=../pkg/grpc --go_opt=paths=source_relative \
         --go-grpc_out=../pkg/grpc --go-grpc_opt=paths=source_relative \
         hello.proto

--go_opt=paths=source_relativeは相対パスを指定するオプションです。

./study_grpc/apiでコマンドを実行したため、相対パスでファイルの保存先を指定しています。

ちなみに--go_opt=paths=source_relativeを使わず、./study_grpc/から実行する場合は、

下記のコマンドになります。

$ protoc --go_out=./ --go-grpc_out=./ api/hello.proto

gRPCサーバーを作成

cmd/server/main.go

package main

import (
  "fmt"
  "net"
  "log"
  "os"
  "context"
  "os/signal"
  "google.golang.org/grpc"
  "google.golang.org/grpc/reflection"
  hellopb "mygrpc/pkg/grpc"
)

func NewMyServer() *myServer {
  return &myServer{}
}

func main() {
  // 1. 8080番portのLisnterを作成
  port := 8080
  listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
  if err != nil {
    panic(err)
  }

  // 2. gRPCサーバーを作成
  s := grpc.NewServer()

  // 3. gRPCサーバーにGreetingServiceを登録
  hellopb.RegisterGreetingServiceServer(s, NewMyServer())

  // 4. サーバーリフレクションの設定
  reflection.Register(s)

  // 5. 作成したgRPCサーバーを、8080番ポートで稼働させる
  go func() {
    log.Printf("start gRPC server port: %v", port)
    s.Serve(listener)
  }()

  // 6.Ctrl+Cが入力されたらGraceful shutdownされるようにする
  quit := make(chan os.Signal, 1)
  signal.Notify(quit, os.Interrupt)
  <-quit
  log.Println("stopping gRPC server...")
  s.GracefulStop()
}

type myServer struct {
  hellopb.UnimplementedGreetingServiceServer
}

func (s *myServer) Hello(ctx context.Context, req *hellopb.HelloRequest) (*hellopb.HelloResponse, error) {
  // リクエストからnameフィールドを取り出して
  // "Hello, [名前]!"というレスポンスを返す
  return &hellopb.HelloResponse{
    Message: fmt.Sprintf("Hello, %s!", req.GetName()),
  }, nil
}

gRPCurlをインストール

gPRCはcurlで動作確認できませんが、gPRCurlを使うことで,

ローカル環境でも動作確認することができます。

$ brew  install grpcurl

gRPCサーバーを起動

これでgRPCサーバーを起動する準備ができました！

下記コマンドを実行してgRPCが起動すれば成功です！

$ go cmd/server/run main.go
2023/02/13 10:01:38 start gRPC server port: 8080

gRPCクライアントを作成

cmd/server/main.go

package main

import (
  "bufio"
  "fmt"
  "os"
  "log"
  "context"
  "google.golang.org/grpc"
  "google.golang.org/grpc/credentials/insecure"
  hellopb "mygrpc/pkg/grpc"
)

var (
  scanner *bufio.Scanner
  client  hellopb.GreetingServiceClient
)

func main() {
  fmt.Println("start gRPC Client.")

  // 1. 標準入力から文字列を受け取るスキャナを用意
  scanner = bufio.NewScanner(os.Stdin)

  // 2. gRPCサーバーとのコネクションを確立
  address := "localhost:8080"
  conn, err := grpc.Dial(
    address,

    grpc.WithTransportCredentials(insecure.NewCredentials()),
    grpc.WithBlock(),
  )
  if err != nil {
    log.Fatal("Connection failed.")
    return
  }
  defer conn.Close()

  // 3. gRPCクライアントを生成
  client = hellopb.NewGreetingServiceClient(conn)

  for {
    fmt.Println("1: send Request")
    fmt.Println("2: exit")
    fmt.Print("please enter >")

    scanner.Scan()
    in := scanner.Text()

    switch in {
    case "1":
      Hello()

    case "2":
      fmt.Println("bye.")
      goto M
    }
  }
M:
}

func Hello() {
  fmt.Println("Please enter your name.")
  scanner.Scan()
  name := scanner.Text()

  req := &hellopb.HelloRequest{
    Name: name,
  }
  res, err := client.Hello(context.Background(), req)
  if err != nil {
    fmt.Println(err)
  } else {
    fmt.Println(res.GetMessage())
  }
}

クライアントを実行して動作確認

gRPCサーバーとは別のターミナルを開いて、下記を実行することで、

gPRCサーバーに対して、リクエスト送信・レスポンス表示をすることができます。

$ go run cmd/client/main.go
start gRPC Client.

1: Hello
2: exit please enter >1

Please enter your name.
shungo
Hello, shungo!

1: Hello
2: exit please enter >2
bye.

このように、リクエスト送信・レスポンスの表示ができれば成功です！

Docker環境で実行する場合

これまではローカル環境にパッケージをインストールして、ローカル環境でgRPC用のコードを生成していました。

gRPC入門の記事を見るとローカルで実行するものが多いですが、バージョン管理などを考慮したらやはりDocker環境で実行したいですよね。

そこで、これまでやってきたことを今後はDocker環境で実行してみようと思います。

Dockerfile

FROM golang:1.19.5-buster

ENV PROTOBUF_VERSION3.17.3

RUN apt-getupdate \
    && apt-getinstall -y protobuf-compiler unzip --no-install-recommends \
    && apt-getclean \
    && rm-rf /var/lib/apt/lists/*

WORKDIR /grpc
COPY. /grpc

## build時のみ使いたいので、runで実行。
RUN go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
RUN go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
RUN go get google.golang.org/grpc/internal/channelz@v1.53.0

docker-compose.yml

version:'3'

services:
  grpc:
    build: .
    volumes:
      - .:/grpc
    ports:
      - "8080:8080"
   tty: true

Docker環境で実行する

1つ目のターミナルでdocker-composeを起動します。

$ docker-compose up

2つ目のターミナルでコンテナに入り、gRPCサーバーを起動します。

$ docker-compose exec grpc bash
> go run cmd/server/main.go
2023/02/13 10:01:38 start gRPC server port: 8080

3つ目のターミナルでコンテナに入り、クライアントを動かします。

$ docker-compose exec grpc bash
> go run cmd/client/main.go
1: Hello
2:exit
please enter>1

Please enter your name.
shungo
Hello, shungo!

1: Hello
2:exit
please enter>2

bye.

これでDocker環境でもgRPCを動かせることを確認できました！

上記では実行していませんが、コンテナ内で同じようにprotocコマンドでコードを生成することも可能です。

The post Docker × Go で gRPC を動かしてみた first appeared on shungo blog.