go-grpc-http1 - GitLite

KO | EN

gitlite — search

#javascript #hacktoberfest #react #ai #typescript #golang #machine-learning #deep-learning #linux #awesome #awesome-list #security #ios #openai

go-grpc-http1

(★ 125)

A gRPC via HTTP/1 Enabling Library for Go

파일 탐색기

최종 버전 다운로드 (.zip)

- - auto-merge.yml
  - ci.yml
- CODEOWNERS
- dependabot.yml
- echo_service.go
- echo_service_test.go
- go.mod
- go.sum
- non_buffering_writer.go
- options.go
- proxy.go
- side_channel_creds.go
- ws_proxy.go
- - do.go
  - signal.go
  - signal_test.go
  - types.go
  - wait.go
- - message.go
  - message_header.go
  - utils.go
- - defs.go
  - defs_test.go
  - response_reader.go
  - response_reader_test.go
  - response_writer.go
- - consts.go
  - write.go
- - error_message.go
- - counting_reader.go
  - io.go
- - pipe_listener.go
  - pipe_listener_test.go
- - size.go
- options.go
- server.go
- websocket_reader.go
- websocket_writer.go
- go.mod
- go.sum
- imports.go
.gitignore
go.mod
go.sum
LICENSE
Makefile
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/stackrox/go-grpc-http1

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd go-grpc-http1

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Go

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Go Go 언어 컴파일러 및 도구 모음입니다.

cd _integration-tests

이 프로젝트의 관련 파일이 하위 폴더 안에 있어서, 먼저 그 폴더로 이동합니다.

go build ./...

Go 프로그램을 컴파일해 실행 파일을 만듭니다.

go run .

따로 빌드하지 않고 바로 Go 프로그램을 실행합니다.

✅ 빌드가 에러 없이 끝나면 성공입니다. go run . 을 썼다면 터미널 출력을 확인하세요.

3. Make

보통

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Make Linux/macOS는 보통 기본 설치되어 있습니다. Windows는 별도 설치(예: MSYS2, WSL)가 필요합니다.

make

생성된 빌드 설정을 바탕으로 실제 컴파일을 진행해 실행 파일을 만듭니다.

✅ 에러 없이 끝나면 성공입니다. 생성된 실행 파일을 직접 실행해보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

grpc-http1: A gRPC via HTTP/1 Enabling Library for Go
====================================================

This library enables using all the functionality of a gRPC server even if it is exposed behind
a reverse proxy which does not support HTTP/2, or only supports it for clients (such as Amazon's ALB).
This is accomplished via either adaptive downgrading to the gRPC-Web response format or utilizing WebSockets.

For a high-level overview, see [this Medium post](https://medium.com/stackrox-engineering/how-to-expose-grpc-services-behind-almost-any-load-balancer-e9ebf8e6d12a)
about the gRPC-Web downgrade option and [this Medium post](https://medium.com/stackrox-engineering/grpc-anywhere-f29616087d54) about the gRPC-WebSocket option.

Connection Compatibility Overview
---------------------------------

The following table shows what can be expected when a client/server instrumented with the capability
offered by this library compared to an unmodified gRPC client/server, both when accessing it directly and
when accessing it via a reverse proxy not supporting HTTP/2.

<table>
<tr><th></th><th colspan="2">Plain Old gRPC Server</th><th colspan="2">HTTP/1 Downgrading gRPC Server</th></tr>
<tr><th></th><th>direct</th><th>behind reverse proxy</th><th>direct</th><th>behind reverse proxy</th></tr>
<tr><td>Plain Old gRPC Client</td><td>:white_check_mark:</td><td>:x:</td><td>:white_check_mark:</td><td>:x:</td></tr>
<tr><td>gRPC-Web downgrade client mode</td><td>:white_check_mark:</td><td>:x:</td><td>:white_check_mark:</td><td>(:white_check_mark:)</td></tr>
<tr><td>gRPC-WebSocket client mode</td><td>:x:</td><td>:x:</td><td>:white_check_mark:</td><td>:white_check_mark:</td></tr>
</table>

The (:white_check_mark:) for the gRPC-Web downgrading client indicates a subset of gRPC calls will be possible, but not
all. These include all calls that do not rely on client-side streaming (i.e., all unary and server-streaming calls).

As you can see, when using the client in gRPC-Web downgrade mode, it is possible to instrument the client **or** the server without any (functional) regressions - there
may be a small but fairly negligible performance penalty. This means rolling this feature out to your clients and
servers does not need to happen in a strictly synchronous fashion. However, you will only be able to work with a server
behind an HTTP/2-incompatible reverse proxy if both the client **and** the server have been instrumented via
this library. To use the client in gRPC-WebSocket mode, both the client **and** server must be instrumented via this library.

Usage
-------------

This library has the canonical import path `golang.stackrox.io/grpc-http1`. It fully supports Go modules
and requires Go version 1.13+ to be built and used. To add it as a dependency in your current project,
run `go get golang.stackrox.io/grpc-http1`.

### Server-side

For using this library on the server-side, you'll need to bypass the regular `(*grpc.Server).Serve` method
and instead use the `ServeHTTP` method of the `*grpc.Server` object -- it is experimental, but we found it
to be fairly stable and reliable.

The only exported function in the `golang.grpc.io/grpc-http1/server` package is `CreateDowngradingHandler`,
which returns a `http.Handler` that can be served by a Go HTTP server. It is crucial this server is
configured to support HTTP/2; otherwise, your clients using the vanilla gRPC client will no longer be able
to talk to it. You can find an example of how to do so in the `_integration-tests/` directory.

### Client-Side

For connecting to a gRPC server via a client-side proxy, use the `ConnectViaProxy` function exported from the
`golang.grpc.io/grpc-http1/client` package. This function has the following signature:
```go
func ConnectViaProxy(ctx context.Context, endpoint string, tlsClientConf *tls.Config, opts ...ConnectOption) (*grpc.ClientConn, error)
```
The first two arguments are the same as for `grpc.DialContext`. The third argument specifies the TLS client
config to be used for connecting to the target address. Note that this is different from the usual gRPC API,
which specifies client TLS config via the `grpc.WithTransportCredentials`. For a plaintext (unencrypted)
connection to the server, pass a `nil` TLS config; however, this does *not* free you from passing the
`grpc.WithInsecure()` (nor `grpc.WithTransportCredentials(insecure.NewCredentials())`) gRPC dial option.

The last (variadic) parameter specifies options that modify the dialing behavior. You can pass any gRPC dial
options via `client.DialOpts(...)`; however, the `grpc.WithTransportCredentials` option will not be needed.
By default, adaptive gRPC-Web downgrading is used. To use WebSockets, pass `true` to the `client.UseWebSocket` option.

Another important option is `client.ForceHTTP2()`, which needs to be used for
a plaintext connection to a server that is *not* HTTP/1.1 capable (e.g., the vanilla gRPC server).
This option is ignored when WebSockets are used. Again, check out the
code in the `_integration-tests` directory.