GRPC

[disco07]

Is it possible to do GRPC with Actix?

[behdad088]

Yes, it is possible to use gRPC with Actix. Actix-web, the web framework for Actix, supports integrating with gRPC using the actix-grpc crate.

The actix-grpc crate provides a server-side gRPC implementation based on Actix-web's HTTP server, as well as a client-side gRPC implementation. You can define your gRPC service using Protocol Buffers and use actix-grpc to generate the necessary Rust code for your service.

To get started with Actix-web and gRPC, you can follow the examples provided in the actix-grpc documentation.

[psandana]

@behdad088 where is the actix-grpc project? I cannot find it.

[behdad088]

Here’s how you can integrate tonic (gRPC) with Actix web:

1. Set Up Dependencies:
   First, add the necessary dependencies for Actix and tonic in your Cargo.toml:

[dependencies]
actix-web = "4"
tonic = "0.10"
tokio = { version = "1", features = ["full"] }
prost = "0.11"
futures = "0.3"

2. Define Your gRPC Service:
   Define your gRPC service using Protocol Buffers. For example, create a proto file like hello.proto:

syntax = "proto3";

package hello;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

3. Generate gRPC Code:
   Use tonic-build to generate Rust code from the .proto file. You can add the following in your build.rs:

fn main() -> Result<(), Box<dyn std::error::Error>> {
    tonic_build::compile_protos("proto/hello.proto")?;
    Ok(())
}

This will generate the necessary client and server code when you build your project.

4. Implement the gRPC Server:
   Now, implement the gRPC server using tonic. For example:

use tonic::{transport::Server, Request, Response, Status};
use hello::greeter_server::{Greeter, GreeterServer};
use hello::{HelloReply, HelloRequest};

pub mod hello {
    tonic::include_proto!("hello");
}

#[derive(Debug, Default)]
pub struct MyGreeter {}

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloReply>, Status> {
        let reply = hello::HelloReply {
            message: format!("Hello {}!", request.into_inner().name),
        };
        Ok(Response::new(reply))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let greeter = MyGreeter::default();

    println!("GreeterServer listening on {}", addr);

    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;

    Ok(())
}

5. Run Actix and gRPC Together:
   You can run both the gRPC server and the Actix HTTP server concurrently using the tokio runtime. Here’s an example of how to combine them:

use actix_web::{web, App, HttpServer, Responder};
use tonic::transport::Server;
use tokio::sync::oneshot;

async fn http_handler() -> impl Responder {
    "Hello from Actix!"
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // Channel to coordinate gRPC shutdown when Actix shuts down
    let (tx, rx) = oneshot::channel();

    // Spawn the gRPC server in a separate task
    tokio::spawn(async move {
        let addr = "[::1]:50051".parse().unwrap();
        let greeter = MyGreeter::default();

        Server::builder()
            .add_service(GreeterServer::new(greeter))
            .serve_with_shutdown(addr, async {
                rx.await.ok();
            })
            .await
            .unwrap();
    });

    // Run Actix server
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(http_handler))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await?;

    // Shutdown gRPC server when Actix shuts down
    let _ = tx.send(());

    Ok(())
}