def get_grpc_server(user_model, seldon_metrics, annotations={}, trace_interceptor=None): seldon_model = SeldonModelGRPC(user_model, seldon_metrics) options = [] if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations: max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE]) logger.info("Setting grpc max message and receive length to %d", max_msg) options.append(("grpc.max_message_length", max_msg)) options.append(("grpc.max_send_message_length", max_msg)) options.append(("grpc.max_receive_message_length", max_msg)) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), options=options) if trace_interceptor: from grpc_opentracing.grpcext import intercept_server server = intercept_server(server, trace_interceptor) prediction_pb2_grpc.add_GenericServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_TransformerServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_OutputTransformerServicer_to_server( seldon_model, server) prediction_pb2_grpc.add_CombinerServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_RouterServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_SeldonServicer_to_server(seldon_model, server) return server
def serve(): config = Config( config={ "sampler": { "type": "const", "param": 1 }, "logging": True }, service_name="chat-server", ) tracer = config.initialize_tracer() tracer_interceptor = open_tracing_server_interceptor(tracer, log_payloads=True) redis_opentracing.init_tracing(tracer_interceptor) redis_client = Redis() kafka_producer = KafkaProducer( bootstrap_servers="127.0.0.1:9092", value_serializer=lambda v: json.dumps(v).encode("utf-8"), ) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) server = intercept_server(server, tracer_interceptor) chat_pb2_grpc.add_ChatServicer_to_server( ChatServicer(tracer, redis_client, kafka_producer), server) server.add_insecure_port("[::]:50051") server.start() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0)
def serve(): """Read in key and cert and start's serving the server.""" Configuration.tracer = init_jaeger_tracer("stub_api") # read in key and certificate with open("certs/tls.key", "rb") as f: private_key = f.read() with open("certs/tls.crt", "rb") as f: certificate_chain = f.read() # create server credentials server_credentials = grpc.ssl_server_credentials( ((private_key, certificate_chain), )) tracer_interceptor = open_tracing_server_interceptor(Configuration.tracer) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) server = intercept_server(server, tracer_interceptor) stub_pb2_grpc.add_StubServicer_to_server( StubServicer(Configuration.tracer), server) server.add_secure_port(f"[::]:{Configuration.GRPC_PORT}", server_credentials) server.start() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0) Configuration.tracer.close()
def serve(): parser = argparse.ArgumentParser() parser.add_argument( '--log_payloads', action='store_true', help='log request/response objects to open-tracing spans') args = parser.parse_args() config = Config(config={ 'sampler': { 'type': 'const', 'param': 1, }, 'logging': True, }, service_name='trivial-server') tracer = config.initialize_tracer() tracer_interceptor = open_tracing_server_interceptor( tracer, log_payloads=args.log_payloads) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) server = intercept_server(server, tracer_interceptor) command_line_pb2.add_CommandLineServicer_to_server(CommandLine(), server) server.add_insecure_port('[::]:50051') server.start() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0) time.sleep(2) tracer.close() time.sleep(2)
def serve(): config = get_config('account-server') tracer = config.initialize_tracer() tracer_interceptor = open_tracing_server_interceptor(tracer, log_payloads=True) server = grpc.server(ThreadPoolExecutor(max_workers=10)) server = intercept_server(server, tracer_interceptor) add_AccountServicer_to_server(Account(), server) server.add_insecure_port('[::]:50051') server.start() wait_for_termination() server.stop(0) tracer.close()
def __init__(self, client_interceptors, server_interceptors, handler=Handler()): self.handler = handler self._server_pool = logging_pool.pool(2) self._server = grpcext.intercept_server(grpc.server(self._server_pool), *server_interceptors) port = self._server.add_insecure_port('[::]:0') self._server.add_generic_rpc_handlers( (_GenericHandler(self.handler), )) self._server.start() self.channel = grpcext.intercept_channel( grpc.insecure_channel('localhost:%d' % port), *client_interceptors)
def get_grpc_server(user_model, seldon_metrics, annotations={}, trace_interceptor=None, num_threads=1): seldon_model = SeldonModelGRPC(user_model, seldon_metrics) options = [ ("grpc.so_reuseport", 1), ] if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations: max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE]) logger.info("Setting grpc max message and receive length to %d", max_msg) options.append(("grpc.max_message_length", max_msg)) options.append(("grpc.max_send_message_length", max_msg)) options.append(("grpc.max_receive_message_length", max_msg)) server = grpc.server(futures.ThreadPoolExecutor(max_workers=num_threads), options=options) if trace_interceptor: from grpc_opentracing.grpcext import intercept_server server = intercept_server(server, trace_interceptor) prediction_pb2_grpc.add_GenericServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_TransformerServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_OutputTransformerServicer_to_server( seldon_model, server) prediction_pb2_grpc.add_CombinerServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_RouterServicer_to_server(seldon_model, server) prediction_pb2_grpc.add_SeldonServicer_to_server(seldon_model, server) SERVICE_NAMES = ( prediction_pb2.DESCRIPTOR.services_by_name["Generic"].full_name, prediction_pb2.DESCRIPTOR.services_by_name["Model"].full_name, prediction_pb2.DESCRIPTOR.services_by_name["Router"].full_name, prediction_pb2.DESCRIPTOR.services_by_name["Transformer"].full_name, prediction_pb2.DESCRIPTOR.services_by_name["OutputTransformer"]. full_name, prediction_pb2.DESCRIPTOR.services_by_name["Combiner"].full_name, prediction_pb2.DESCRIPTOR.services_by_name["Seldon"].full_name, reflection.SERVICE_NAME, ) reflection.enable_server_reflection(SERVICE_NAMES, server) return server
def serve(): grpc_server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) tracer_interceptor = open_tracing_server_interceptor(tracer) grpc_server = intercept_server(grpc_server, tracer_interceptor) hello_pb2_grpc.add_HelloServerServicer_to_server(Greeter(), grpc_server) grpc_server.add_insecure_port('[::]:50051') grpc_server.start() # grpc_server.wait_for_termination() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: grpc_server.stop(0) tracer.close()
def get_grpc_server(user_model, debug=False, annotations={}, trace_interceptor=None): seldon_model = SeldonTransformerGRPC(user_model) options = [] if ANNOTATION_GRPC_MAX_MSG_SIZE in annotations: max_msg = int(annotations[ANNOTATION_GRPC_MAX_MSG_SIZE]) logger.info("Setting grpc max message to %d", max_msg) options.append(('grpc.max_message_length', max_msg)) server = grpc.server(futures.ThreadPoolExecutor( max_workers=10), options=options) if trace_interceptor: from grpc_opentracing.grpcext import intercept_server server = intercept_server(server, trace_interceptor) prediction_pb2_grpc.add_ModelServicer_to_server(seldon_model, server) return server
def serve(): parser = argparse.ArgumentParser() parser.add_argument( '--log_payloads', action='store_true', help='log request/response objects to open-tracing spans') parser.add_argument( '--include_grpc_tags', action='store_true', help='set gRPC-specific tags on spans') args = parser.parse_args() config = Config( config={ 'sampler': { 'type': 'const', 'param': 1, }, 'logging': True, }, service_name='store-server') tracer = config.initialize_tracer() span_decorator = None if args.include_grpc_tags: span_decorator = StoreSpanDecorator() tracer_interceptor = open_tracing_server_interceptor( tracer, log_payloads=args.log_payloads, span_decorator=span_decorator) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) server = intercept_server(server, tracer_interceptor) store_pb2.add_StoreServicer_to_server(Store(), server) server.add_insecure_port('[::]:50051') server.start() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0) time.sleep(2) tracer.close() time.sleep(2)
def serve(self): config = Config( config={ # usually read from some yaml config 'sampler': { 'type': 'const', # 全部 'param': 1, # 1 开启全部采样 0 表示关闭全部采样 }, 'local_agent': { 'reporting_host': '192.168.0.14', 'reporting_port': '6831', }, 'logging': True, }, service_name='order-srv', validate=True, ) tracer = config.initialize_tracer() self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=40)) tracing_interceptor = open_tracing_server_interceptor(tracer) self.server = intercept_server(self.server, tracing_interceptor) order_pb2_grpc.add_OrderServicer_to_server(OrderService(), self.server) health_servicer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(health_servicer, self.server) self.server.add_insecure_port(f'[::]:{self.SERVICE_PORT}') signal.signal(signal.SIGINT, self.onExit) signal.signal(signal.SIGTERM, self.onExit) logger.info("Start Order Service at {}:{}".format( self.SERVICE_HOST, self.SERVICE_PORT)) self.server.start() self.register() #监听超时订单消息 consumer = PushConsumer("mxshop_order") consumer.set_name_server_address( f"{settings.RocketMQ_HOST}:{settings.RocketMQ_PORT}") consumer.subscribe("order_timeout", order_timeout) consumer.start() self.server.wait_for_termination() consumer.shutdown()
def intercept_grpc_server(server, tracer): tracer_interceptor = open_tracing_server_interceptor(tracer) new_server = intercept_server(server, tracer_interceptor) return new_server
def _enable_trace(self, server, tracer): from grpc_opentracing import open_tracing_server_interceptor from grpc_opentracing.grpcext import intercept_server tracer_interceptor = open_tracing_server_interceptor(tracer) return intercept_server(server, tracer_interceptor)