public void start() {

      final JsonObject conf = container.config();
      final Long keepAliveTimeOut = conf.getLong("keepAliveTimeOut", 2000L);
      final Long keepAliveMaxRequest = conf.getLong("maxKeepAliveRequests", 100L);
      final Integer clientRequestTimeOut = conf.getInteger("clientRequestTimeOut", 60000);
      final Integer clientConnectionTimeOut = conf.getInteger("clientConnectionTimeOut", 60000);
      final Boolean clientForceKeepAlive = conf.getBoolean("clientForceKeepAlive", false);
      final Integer clientMaxPoolSize = conf.getInteger("clientMaxPoolSize",1);
      final Long serverResponseTimeout = conf.getLong("serverResponseTimeout",1000L);

      final HashSet<Client> clients = new HashSet<>();
      final HashSet<Client> clients2 = new HashSet<>();

      boolean local = conf.containsField("local");
      if (local) {
          clients.add(new Client("127.0.0.1:8081"));
          clients.add(new Client("127.0.0.1:8082"));
          clients2.add(new Client("127.0.0.1:8083"));
          clients2.add(new Client("127.0.0.1:8084"));
      } else {
          clients.add(new Client("10.248.92.35:80"));
          clients.add(new Client("10.248.92.36:80"));
          clients2.add(new Client("10.249.51.4:80"));
          clients2.add(new Client("10.249.51.5:80"));
      }

     final HashMap<String, HashSet<Client>> vhosts = new HashMap<>();
     vhosts.put("teste.qa02.globoi.com", clients);
     vhosts.put("teste2.qa02.globoi.com", clients2);

     final Handler<HttpServerRequest> handlerHttpServerRequest = new Handler<HttpServerRequest>() {
        @Override
        public void handle(final HttpServerRequest sRequest) {

            final ServerResponse serverResponse = new ServerResponse(sRequest.response().setChunked(true));

            final Long requestTimeoutTimer = vertx.setTimer(clientRequestTimeOut, new Handler<Long>() {
                @Override
                public void handle(Long event) {
                    serverShowErrorAndClose(serverResponse.getResponse(), new java.util.concurrent.TimeoutException());
                }
            });

            String headerHost = sRequest.headers().get("Host").split(":")[0];

            final boolean connectionKeepalive = sRequest.headers().contains("Connection") ?
                    (!sRequest.headers().get("Connection").equals("close")) : 
                    sRequest.version().equals(HttpVersion.HTTP_1_1);

            final Client client = ((Client)vhosts.get(headerHost).toArray()[getChoice(clients.size())])
                    .setKeepAlive(connectionKeepalive||clientForceKeepAlive)
                    .setKeepAliveTimeOut(keepAliveTimeOut)
                    .setKeepAliveMaxRequest(keepAliveMaxRequest)
                    .setConnectionTimeout(clientConnectionTimeOut)
                    .setMaxPoolSize(clientMaxPoolSize);

            final Handler<HttpClientResponse> handlerHttpClientResponse = new Handler<HttpClientResponse>() {

                    @Override
                    public void handle(HttpClientResponse cResponse) {

                        vertx.cancelTimer(requestTimeoutTimer);

                        // Pump cResponse => sResponse
                        serverResponse.getResponse().headers().set(cResponse.headers());
                        if (!connectionKeepalive) {
                            serverResponse.getResponse().headers().set("Connection", "close");
                        }
                        Pump.createPump(cResponse, serverResponse.getResponse()).start();

                        cResponse.endHandler(new VoidHandler() {
                            @Override
                            public void handle() {
                                serverResponse.getResponse().end();
                                if (connectionKeepalive) {
                                    if (client.isKeepAliveLimit()) {
                                        client.close();
                                    }
                                } else {
                                    if (!clientForceKeepAlive) {
                                        client.close();
                                    }
                                }
                            }
                        });

                        cResponse.exceptionHandler(new Handler<Throwable>() {
                            @Override
                            public void handle(Throwable event) {
//                                System.err.println(event.getMessage());
                                serverShowErrorAndClose(serverResponse.getResponse(), event);
                                client.close();
                            }
                        });
                }
            };

            final HttpClientRequest cRequest = client.connect()
                    .request(sRequest.method(), sRequest.uri(),handlerHttpClientResponse)
                    .setChunked(true);

            cRequest.headers().set(sRequest.headers());
            if (clientForceKeepAlive) {
                cRequest.headers().set("Connection", "keep-alive");
            }
            // Pump sRequest => cRequest
            Pump.createPump(sRequest, cRequest).start();

            cRequest.exceptionHandler(new Handler<Throwable>() {
                @Override
                public void handle(Throwable event) {
                    System.err.println(event.getMessage());
                    serverShowErrorAndClose(serverResponse.getResponse(), event);
                    client.close();
                }
             });

            sRequest.endHandler(new VoidHandler() {
                @Override
                public void handle() {
                    cRequest.end();
                }
             });
        }
    };

    vertx.createHttpServer().requestHandler(handlerHttpServerRequest)
        .setTCPKeepAlive(conf.getBoolean("serverTCPKeepAlive",true))
        .listen(conf.getInteger("port",8080));

  }