info!("Start CloudState gRPC in 0.0.0.0:{}", opts.server_port);
                Server::builder()
                    .serve(
                        addr,
                        Router {
                            entity_discovery: Arc::new(EntityDiscoveryServer::new(discover))
                        })
                    .await
                    .map_err(|err| error!("Error during start server phase: {:?}", err))
                    .ok();


And my service implementation is:
use crate::protocol::spec::{
        server::{EntityDiscovery, EntityDiscoveryServer},
        ProxyInfo, EntitySpec, ServiceInfo, Entity,UserFunctionError,
    };

    use crate::protocol::router::Router;

    pub struct Discover {
        pub opts: Options,
    }

    #[tonic::async_trait]
    impl EntityDiscovery for Discover {

        async fn discover(
            &self,
            request: Request<ProxyInfo>,
        ) -> Result<Response<EntitySpec>, Status> {

            let metadata = request.metadata();
            let proxy_info: &ProxyInfo = request.get_ref();

            debug!("Received discovery call from sidecar with Metadata [{:?}", metadata );
            info!("Received discovery call from sidecar [{:?} {:?}] supporting CloudState {:?}.{:?}", proxy_info.proxy_name, proxy_info.proxy_version, proxy_info.protocol_major_version, proxy_info.protocol_minor_version);
            info!("Supported sidecar entity types: {:?}", proxy_info.supported_entity_types);

            let entity = Entity {
                entity_type: self.opts.entity_type.to_string(),
                service_name: self.opts.service_name.to_string(),
                persistence_id: self.opts.persistence_id.to_string(),
            };

            let vec_entities = vec![entity];

            let lib_name: String = "cloudstate-rust-support".to_string();
            let lib_version: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
            let runtime = "rustc ".to_owned() + &version().unwrap().to_string();

            let info = ServiceInfo {
                service_name: self.opts.service_name.to_string(),
                service_version: self.opts.service_version.to_string(),
                service_runtime: runtime,
                support_library_name: lib_name,
                support_library_version: lib_version.unwrap_or("0.0.1").to_string(),
            };

            /*FileDescriptorSet{
                file: vec![]
            }*/

            let reply = EntitySpec {
                proto: vec![],
                entities: vec_entities,
                service_info: Some(info),
            };

            Ok(Response::new(reply))
        }

        // Handle Sidecar Errors Messages
        async fn report_error(
            &self,
            request: Request<UserFunctionError>,
        ) -> Result<Response<()>, Status> {

            let metadata = request.metadata();
            let user_func_error: &UserFunctionError = request.get_ref();

            debug!("Receive request for report_error. Metadata: {:?}", metadata );
            error!("Received report_error from sidecar. Error: {:?}", user_func_error.message);
            Ok(Response::new(()))
        }

    }