github.com/micro-in-cn/tutorials/microservice-in-micro/part3/orders-web

main中服务名写错了！

go-micro中集成gorm

go: extracting github.com/micro-in-cn/tutorials v0.0.0-20190731012511-7dc16d5154d8
-> unzip ~/go/pkg/mod/cache/download/github.com/micro-in-cn/tutorials/@v/v0.0.0-20190731012511-7dc16d5154d8.zip: unexpected file name github.com/

func (router *router) sendResponse(sending sync.Locker, req *request, reply interface{}, cc codec.Writer, last bool) error {
msg := new(codec.Message)
msg.Type = codec.Response
resp := router.getResponse()
resp.msg = msg
resp.msg.Id = req.msg.Id
sending.Lock()
err := cc.Write(resp.msg, reply)
sending.Unlock()
router.freeResponse(resp)
return err
}

我看这里只是复制返回 ID 字段

在文档中了解到它们都是对外暴露服务，那么WEB和API它们之间有什么异同呢？看您的教程中使用的是WEB，用API是否也可以实现呢？感谢。

希望尽快看到您的教程

https://github.com/micro-in-cn/tutorials/tree/master/examples/basic-practices/micro-api/proxy
最后一行，
“请保存上传保存的目录存在，且上传小文件”，可能应该是“请保证上传保存的目录存在，且上传小文件”

这个请问下作者，这个在编译运行时就出现无法加载，要怎么处理呢

使用part4的config-grpc-srv,当配置文件变更起来2次后，loadAndWatchConfigFile不再打印"文件变动"

在开发中，需要写一个通用包请求某服务srv获得数据，在有srv id和端口的情况下怎么去请求这个srv。类似在命令行中使用micro call 方法 参数即可获得，尝试用标准库中的net/rpc去请求，是否也可以？

服务：/tutorials/microservice-in-micro/part1
执行的命令：

$ micro --registry=consul --registry_address=192.168.2.227:8500 --api_namespace=mu.micro.book.web  api --handler=web

user-srv ,user-web的consul配置

app:
  consul:
    enabled: true
    host: 192.168.2.227
    port: 8500

调试命令

$ 
curl --request POST   --url http://127.0.0.1:8080/user/login   --header 'Content-Type: application/x-www-form-urlencoded'  --data 'userName=micro&pwd=1234'

得到的结果

我自己怀疑是不是consul中有些历史数据没有清理干净？我手动deregister了，但问题依旧，不知为何？

看了你写的go的入门，非常不错，请问这篇文章还更新吗

第三方的包，我使用dep来管理的。所以我加载的包，都是独立的。
我在第一章里，按照/user-web/handler/handler.go的代码写。编译时，第25行报错。如下：
看报错应该意思是我应该用 srv 里的 client 包。可是srv的vendor在web里是无法使用的。所以想请教大佬，这种情况，我该如何解决？或者有什么办法绕过去么？

handler/handler.go:23:36: cannot use "user-web/vendor/github.com/micro/go-micro/client".DefaultClient (type "user-web/vendor/github.com/micro/go-micro/client".Client) as type "user-srv/vendor/github.com/micro/go-micro/client".Client in argument to mu_micro_book_srv_user.NewUserService:
        "user-web/vendor/github.com/micro/go-micro/client".Client does not implement "user-srv/vendor/github.com/micro/go-micro/client".Client (wrong type for Call method)
                have Call(context.Context, "user-web/vendor/github.com/micro/go-micro/client".Request, interface {}, ..."user-web/vendor/github.com/micro/go-micro/client".CallOption) error
                want Call(context.Context, "user-srv/vendor/github.com/micro/go-micro/client".Request, interface {}, ..."user-srv/vendor/github.com/micro/go-micro/client".CallOption) error

micro.NewService 和 grpc.NewService
这两个有啥区别吗？
micro.NewService这个底层用的是grpc吗？还是基于 http的自定义rpc协议啊

我看教程使用的是--handle=web，然后转发的每个服务的web（客户端），然后rpc调用各个服务。
如果把--handle=api, 然后rpc调用每个服务的客户端，客户端在rpc调用各个服务。这样性能更高吧，官方的examples->booking例子就是这样做的。

example 中的broker和pubsub有什么区别
是用broker 更高效吗
broker有发送的消息直能是字符串吗
我发现没有安装rabbitmq 或者nats也能运行

part实例部分：通过暴露的web接口取访问srv，提示超时了

1. 错误返回
   curl --request POST --url http://127.0.0.1:8080/user/login --header 'Content-Type:application/x-www-f orm-urlencoded' --data 'userName=micro&pwd=1234'
   {"id":"go.micro.client","code":408,"detail":"call timeout: context deadline exceeded","status":"Request Timeout"}
2. micro 查询服务结果
   λ micro -registry=consul list services
   consul
   mu.micro.book.srv.user
   mu.micro.book.web.user
3. micro直接调用src结果是可以的
   λ micro --registry=consul call mu.micro.book.srv.user User.QueryUserByName "{"userName":"micro"}"
   {
   "success": true,
   "user": {
   "id": 10001,
   "name": "micro",
   "pwd": "1234"
   }
   }

https://micro.mu/docs/cn/architecture.html

Broker
Broker是事件广播/订阅可插件接口。对于事件驱动的微服务架构，消息广播与订阅得放在首要位置。目前的实现有NATs、rabbitmq、http (仍在开发中)。

应该是Broker是事件广播/订阅可插拔接口吧

/Users/wujixin/go/src/github.com/micro-in-cn/tutorials/microservice-in-micro/part4

这个例子我实际测试了，不可以，配置中心修改了数据库（密码改错），服务收到变化，一样可以连接数据库，只有重启服务才生效，无法不重启热重载

还有个问题，配置中心端口8600和consul冲突了。

micro api 如何以守候进程的方式启动，命令行窗口的方式启动， 总是会被杀掉

每个服务都有WEB层会不会冗余？提供的WEB层是给外界调用还是服务间通信用的？我认为"WEB层"应该在API处统一暴露给外界来提供接口，服务间通过rpc来通信。

[root@k8s-deploy micro-k8s-test]# kubectl get pods
NAME READY STATUS RESTARTS AGE
greeter-66659f774c-v4jkl 1/1 Running 0 4s
[root@k8s-deploy micro-k8s-test]# docker logs greeter-66659f774c-v4jkl
Error: No such container: greeter-66659f774c-v4jkl
[root@k8s-deploy micro-k8s-test]# kubectl logs greeter-66659f774c-v4jkl
2019/06/04 15:38:03 Listening on [::]:8080
2019/06/04 15:38:03 Broker Listening on [::]:10001
2019/06/04 15:38:03 Broker [grpc] Listening on [::]:10001
2019/06/04 15:38:03 Registering node: micro.greeter-f8c284a2-9921-4799-9abd-6422fa1a8f21
2019/06/04 15:38:03 K8s: request failed with code 403
2019/06/04 15:38:03 K8s: request failed with body:
2019/06/04 15:38:03 {"kind":"Status","apiVersion":"v1","metadata":{},"status":"Failure","message":"pods "greeter-66659f774c-v4jkl" is forbidden: User "system:serviceaccount:default:default" cannot patch resource "pods" in API group "" in the namespace "default"","reason":"Forbidden","details":{"name":"greeter-66659f774c-v4jkl","kind":"pods"},"code":403}

rpcx也是golang开发的微服务框架，自带服务治理，其他和go-micro类似，用它岂不是更方便?

首先非常感谢，提供这么好的教程，这个是我目前在网上找的最好的一个教程了。

关于微服务之间的相互调用的疑问：
拿教程中的代码举例，比如订单服务（order-srv）和支付服务（payment-srv）都需要调用库存服务（inventory-srv）。
订单服务中需要调用库存微服务，需要先引入库存微服务的代码，然后创建client：
1、先import

invS "github.com/micro-in-cn/tutorials/microservice-in-micro/part3/inventory-srv/proto/inventory"

2、创建客户端

invClient = invS.NewInventoryService("mu.micro.book.srv.inventory", client.DefaultClient)

这里订单微服务的代码里就必须依赖于库存微服务中的文件“github.com/micro-in-cn/tutorials/microservice-in-micro/part3/inventory-srv/proto/inventory” 才能调用到库存服务了。

我的疑问：
1、假设订单微服务是go语言写的，而库存微服务是java写的，那我该如何调用到库存服务了呢？
2、即便订单和库存服务都是go写的（都基于go-micro），假设订单服务是A部门写的，库存服务是B部门写的，两个部门代码托管都是独立的，各自独立部署，但是共用同一个发现服务。这种情况下两个服务之间怎么才能相互调用呢（RPC调用，不走http api请求）。

我也是最近开始了解微服务，我的理解，各个微服务之间无论是代码还是部署应该都尽可能独立，但是上面举例的调用方式不是与微服务的**有点不符吗？

不知道是不是我对微服务的理解有很大偏差，还请大神指导。

我看教程中订单服务-下单接口，先是调用远程库存服务减库存，那如果减库存成功了，插入订单记录失败了，如何回滚减库存操作。（例子中没有用到分布式事务，如何保证事务的acid了），有什么分布式事务解决方案推介吗

time库没使用，需要去掉

在docker容器化服务之后，每个服务的web或srv为一个服务，还是整一个user登录模块（web和srv）为一个服务打包起来。tutorials/microservice-in-micro/part1/第一章 用户服务

@printfcoder

有没有考虑过实现一个UDP transport ? 实现UDP 的accept和net.Conn似乎有点问，因为这是TCP的思路，要用UDP模拟实现。

另外，你手边有没有在go-micro上使用原始tcp tranport 的例子?

定义User原型中提到了service.proto，但是在protoc中并没有编译service.proto，main.go里面却疑似用到了service.proto。

另外建议在part1的git目录下放置完整例子方便比对。

作者你好！
part3/orders-web/handler疑似存在错误：
1、wrapper.go里的authClient调用的方法GetCachedAccessToken，我猜测应该是auth/hander里的方法，这个方法有问题，需要返回(rsp *auth.Response, err error)
2、authClient是在隔壁的handler.go里暴露的，这个authClient的定义应该是auth/hander里Service结构体的指针，而不是auth/proto/auth里的Service结构体

请参考！

part1:

basic/db/mysql.go 是不是要import driver

_ "github.com/go-sql-driver/mysql"

proto文件定义如下:
`syntax = "proto3";

import "github.com/micro/go-micro/api/proto/api.proto";

service Test {
rpc Hi(proto.Request) returns (proto.Response) {};
}
`
proto文件路径为$GOPATH/test/api-api/proto/api.proto

生成pd.go文件时是在$GOPATH/test/api-api下执行的命令
protoc --proto_path=proto --proto_path=D:/Golang_Code/micro/src --go_out=proto --micro_out=proto api.proto

https://github.com/qin-jd/shopping
可供参考

error message

{
    "id": "go.micro.client",
    "code": 500,
    "detail": "error selecting greeter node: not found",
    "status": "Internal Server Error"
}

greeter-web

package main

import (
	"fmt"
	"log"
	"net/http"

	hello "github.com/micro/examples/greeter/srv/proto/hello"
	"github.com/micro/go-micro/client"
	"github.com/micro/go-web"
	k8s "github.com/micro/kubernetes/go/web"

	"context"
)

func main() {
	service := k8s.NewService(
		web.Name("go.micro.web.greeter"),
	)

	service.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if r.Method == "POST" {
			r.ParseForm()

			name := r.Form.Get("name")
			if len(name) == 0 {
				name = "World"
			}

			cl := hello.NewSayService("greeter", client.DefaultClient)
			rsp, err := cl.Hello(context.Background(), &hello.Request{
				Name: name,
			})

			if err != nil {
				http.Error(w, err.Error(), 500)
				return
			}

			w.Write([]byte(`<html><body><h1>` + rsp.Msg + `</h1></body></html>`))
			return
		}

		fmt.Fprint(w, `<html><body><h1>Enter Name<h1><form method=post><input name=name type=text /></form></body></html>`)
	})

	if err := service.Init(); err != nil {
		log.Fatal(err)
	}

	if err := service.Run(); err != nil {
		log.Fatal(err)
	}
}

greeter-srv

package main

import (
	"log"
	"time"

	hello "github.com/micro/examples/greeter/srv/proto/hello"
	"github.com/micro/go-micro"
	k8s "github.com/micro/kubernetes/go/micro"
	"context"
)

type Say struct{}

func (s *Say) Hello(ctx context.Context, req *hello.Request, rsp *hello.Response) error {
	log.Print("Received Say.Hello request")
	rsp.Msg = "Hello " + req.Name
	return nil
}

func main() {
	service := k8s.NewService(
		micro.Name("greeter"),
		micro.RegisterTTL(time.Second*30),
		micro.RegisterInterval(time.Second*10),
	)

	// optionally setup command line usage
	service.Init()

	// Register Handlers
	hello.RegisterSayHandler(service.Server(), new(Say))

	// Run server
	if err := service.Run(); err != nil {
		log.Fatal(err)
	}
}

greeter-srv service

apiVersion: v1
kind: Service
metadata:
  name: greeter
  namespace: micro
  labels:
    app: greeter
spec:
  ports:
    - port: 8080
      protocol: TCP
  selector:
    name: greeter-srv

greater-srv pod

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: micro
  name: greeter
spec:
  replicas: 1
  selector:
    matchLabels:
      name: greeter-srv
  template:
    metadata:
      labels:
        name: greeter-srv
    spec:
      containers:
        - name: greeter
          command: [
            "/greeter-srv",
            "--selector=static",
            "--server_address=0.0.0.0:8080",
            "--broker_address=0.0.0.0:10001"
          ]
          image: harbor.my.work.com/micro-test/greeter-srv:latest
          imagePullPolicy: Always
          ports:
            - containerPort: 8080
              name: greeter-port
        - name: health
          command: [
            "/health",
            "--health_address=0.0.0.0:8081",
            "--server_name=greeter",
            "--server_address=0.0.0.0:8080"
          ]
          image: harbor.my.work.com/micro-test/health:latest
          imagePullPolicy: Always
          livenessProbe:
            httpGet:
              path: /health
              port: 8081
            initialDelaySeconds: 3
            periodSeconds: 3

[root@bogon ~]# go get github.com/micro/go-micro

cd .; git clone https://github.com/micro/go-micro /root/goPackages/src/github.com/micro/go-micro

正克隆到 '/root/goPackages/src/github.com/micro/go-micro'...
fatal: unable to access 'https://github.com/micro/go-micro/': Encountered end of file

是按照教程依次执行
micro --registry=consul --api_namespace=mu.micro.book.web  api --handler=web
user-srv   go run main.go 
user-web go run main.go

Consul Services

你好，请问一下，micro中文文档中之前关于Wrapper包装器的部分怎么不见了

go-micro grpc server 不是一个请求一个groutine, 如何函数panic了，服务就挂了。 怎么优化， 像gin 这样， 一个 http 请求 一个 groutine, 如何panic了，只是 函数panic, 可以recover 住，服务不会挂。 go-micro 有没有 全局 recover 中间件。

你好，auth服务中的GetCachedAccessToken方法中ID: strconv.FormatInt(req.UserId, 10),这一句报错，应该是ID: strconv.FormatUint(req.UserId, 10),

1. 192.168.1.3 启动网关 micro api --handler=api --namespace=com.test.api
2. 192.168.1.4 启动服务api/user go run main.go --registry_address=192.168.1.3
3. 192.168.1.4 启动服务srv/user go run main.go --registry_address=192.168.1.3

访问 192.168.1.3:8080没有问题但是如果换成consul后

1. 192.168.1.3启动consul consul agent -dev -ui -client 0.0.0.0
2. 192.168.1.3 启动网关 MICRO_REGISTRY=consul MICRO_REGISRY_ADDRESS=192.168.1.3 micro api --namespace=com.test.api --handler=api
3. 192.168.1.4 启动服务api/user go run main.go --registry=consul --registry_address=192.168.1.3
4. 192.168.1.4 启动服务srv/user go run main.go --registry=consul --registry_address=192.168.1.3

会报错user 的srv 找不到但是 user api 能访问,访问consul的ui也能看到user的srv是正常的 我想问是因为设置或启动或代码缺少参数吗

micro 和go-micro 的版本都是micro version 1.9.1

java微服务体系中有saga来保证微服务之间的事务， golang这边有什么好的插件来保证微服务之间事务原子性吗？

期待链路追踪啊，k8s-greeter的例子可以出个吗，官方就给出了如何创建yaml文件，整个微服务如何部属到上面也没有，github问作者也不回，醉了

我们最近在准备Golang夜读关于Go-Micro的分享，想看看大家的意见，希望大家留言给建议！非常期待

夜读链接：reading-go

我看教程就介绍了api网关支持不同类型的转发，那么问题来了，kong API网关支持的：
HTTP 基本认证、密钥认证、CORS（ Cross-origin Resource Sharing，跨域资源共享）、TCP、UDP、文件日志、API 请求限流、请求转发以及 nginx 监控。
我如何在micro api 中实现了

mysql.go 的 initMysql() 要返回连接对象，并赋值给db.go:mysqlDB，不然 db.go:GetDB() 返回是nil

func initMysql() *sql.DB

micro.WrapHandler(openTrace.NewHandlerWrapper())
中的
openTrace.NewHandlerWrapper()缺少参数

我看例子执行了一下，第二章，有时候会报这个错，是不是存在不稳定性呀！curl --request POST --url http://127.0.0.1:8088/user/login --header 'Content-Type: application/x-www-form-urlencoded' --data 'userName=micro&pwd=123'
{"id":"go.micro.client","code":500,"detail":"connection error: dial tcp 192.168.16.158:51167: connect: connection refused","status":"Internal Server Error"}
p

micro new --namespace=mu.micro.book --type=srv --alias=user github.com/micro-in-cn/tutorials/microservice-in-micro/part1/user-srv

为什么最后要跟一段 网址呢？？为什么不是 本地的一个 path呢？