title: Python gRPC Server Not Starting
body: <p>I've create a gRPC server using proto3 and python to do basic health checking on a long running daemon. When I start my application though, it doesn't actually start the gRPC server. I was wondering if anyone could help identify why it doesn't start and serve the gRPC API</p>
  
  <p>Proto Definition: health.proto</p>
  
  <pre><code>syntax = "proto3";
  
  option java_multiple_files = true;
  option java_package = "com.redacted.example.worker";
  option java_outer_classname = "ExampleWorker";
  option objc_class_prefix = "DSW";
  
  package exampleworker;
  
  service Worker {
    rpc Health (Ping) returns (Pong) {}
  }
  
  // The request message containing PONG
  message Ping {
    string message = 1;
  }
  
  // The response message containing PONG
  message Pong {
    string message = 1;
  }
  </code></pre>
  
  <p>Then I generated the python code using:</p>
  
  <pre><code>python -m grpc_tools.protoc -I=../protos --python_out=. --grpc_python_out=. ../protos/health.proto
  </code></pre>
  
  <p>This generated the <code>health_pb2.py</code> and <code>health_pb2_grpc.py</code> files. I next created a server file:</p>
  
  <pre><code>u"""Health server is used to create a new health monitoring GRPC server."""
  
  from concurrent import futures
  import logging
  import grpc
  import health_pb2
  import health_pb2_grpc
  
  # grpc related variables
  grpc_host = u'[::]'
  grpc_port = u'50001'
  grpc_address = u'{host}:{port}'.format(host=grpc_host, port=grpc_port)
  # logging related variables
  logger = logging.getLogger(__name__)
  logger.setLevel(logging.INFO)
  
  
  class WorkerServicer(health_pb2_grpc.WorkerServicer):
      u"""Provides methods that implement functionality of health server."""
  
      def Health(self, request, context):
          u"""Return PONG to say the Worker is alive."""
          return health_pb2.Pong(message='PONG')
  
  
  def serve_health_api():
      u"""Create and start the GRPC server."""
      server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
      health_pb2_grpc.add_WorkerServicer_to_server(WorkerServicer(), server)
      logging.info(u'adding port {grpc_address}'.format(
          grpc_address=grpc_address))
      server.add_insecure_port(grpc_address)
      server.start()
  </code></pre>
  
  <p>Then in my main run.py file:</p>
  
  <pre><code>#!mac/bin/python
  
  """Run is the local (non-wsgi) entrypoint to the flask application."""
  
  from subscriber.worker import Worker
  from redis import StrictRedis
  from examplegrpc.health_server import serve_health_api
  import logging
  
  redis_host = 'localhost'
  redis_port = 6379
  redis_db = 0
  redis_chan = 'deployment'
  
  if __name__ == "__main__":
      FORMAT = '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'
      logging.basicConfig(format=FORMAT)
      logger = logging.getLogger(__name__)
      logger.setLevel(logging.INFO)
  
      logger.debug('Creating redis client')
      client = StrictRedis(host=redis_host, port=redis_port, db=redis_db)
      w = Worker(client, [redis_chan])
      try:
          logger.info('Starting Health gRPC API...')
          serve_health_api()
          logger.info('Starting worker...')
          w.run()
      except KeyboardInterrupt:
          logger.info('Exiting...')
  </code></pre>
  
  <p>The w.run() starts correctly to execute work off of a redis channel, but the gRPC server does not start as trying to access it with</p>
  
  <pre><code>channel = grpc.insecure_channel('localhost:{port}'.format(port=grpc_port))
  stub = WorkerStub(channel)
  ping = examplegrpc.health_pb2.Ping(message='PING')
  health = stub.Health(ping)
  </code></pre>
  
  <p>starts</p>
  
  <pre><code>_Rendezvous: &lt;_Rendezvous of RPC that terminated with (StatusCode.UNAVAILABLE, Connect Failed)&gt;
  </code></pre>