Google Cloud client libraries use HTTPS and gRPC in underlying communication
with the services. In both protocols, you can configure a proxy using
`https.proxyHost` and, optionally, `https.proxyPort` properties.

## Configure a proxy with HTTP

For HTTP clients, you can configure a basic proxy by using `http.proxyHost` and
related system properties, as documented by
[Java Networking and Proxies](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html).

For a custom proxy (for example, an authenticated proxy), provide a
custom `HttpTransportFactory` to `GoogleCredentials`:

```java
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.apache.v2.ApacheHttpTransport;
import com.google.auth.http.HttpTransportFactory;
import com.google.auth.oauth2.GoogleCredentials;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.routing.HttpRoutePlanner;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.ProxyAuthenticationStrategy;
import org.apache.http.impl.conn.DefaultProxyRoutePlanner;


import java.io.IOException;


public class ProxyExample {
 public GoogleCredentials getCredentials() throws IOException {
   HttpTransportFactory httpTransportFactory = getHttpTransportFactory(
       "some-host", 8080, "some-username", "some-password"
   );


   return GoogleCredentials.getApplicationDefault(httpTransportFactory);
 }


 public HttpTransportFactory getHttpTransportFactory(String proxyHost, int proxyPort, String proxyUsername, String proxyPassword) {
   HttpHost proxyHostDetails = new HttpHost(proxyHost, proxyPort);
   HttpRoutePlanner httpRoutePlanner = new DefaultProxyRoutePlanner(proxyHostDetails);


   CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
   credentialsProvider.setCredentials(
       new AuthScope(proxyHostDetails.getHostName(), proxyHostDetails.getPort()),
       new UsernamePasswordCredentials(proxyUsername, proxyPassword)
   );


   HttpClient httpClient = ApacheHttpTransport.newDefaultHttpClientBuilder()
       .setRoutePlanner(httpRoutePlanner)
       .setProxyAuthenticationStrategy(ProxyAuthenticationStrategy.INSTANCE)
       .setDefaultCredentialsProvider(credentialsProvider)
       .build();


   final HttpTransport httpTransport = new ApacheHttpTransport(httpClient);
   return new HttpTransportFactory() {
     @Override
     public HttpTransport create() {
       return httpTransport;
     }
   };
 }
}
```

The preceding example requires `com.google.http-client:google-http-client-apache-v2`.

## Configure a proxy with a gRPC custom proxy configuration

For a custom proxy with gRPC, supply a `ProxyDetector` to
the `ManagedChannelBuilder`:

Replace `PROXY_USERNAME`, `PROXY_PASSWORD`, `PROXY_HOST`, and `PROXY_PORT`
with the credentials and address of your proxy.

```java
import com.google.api.core.ApiFunction;
import com.google.api.gax.rpc.TransportChannelProvider;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.CloudTasksSettings;
import com.google.cloud.tasks.v2.stub.CloudTasksStubSettings;
import io.grpc.HttpConnectProxiedSocketAddress;
import io.grpc.ManagedChannelBuilder;
import io.grpc.ProxiedSocketAddress;
import io.grpc.ProxyDetector;

import javax.annotation.Nullable;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;

public CloudTasksClient getService() throws IOException {
  TransportChannelProvider transportChannelProvider =
      CloudTasksStubSettings.defaultGrpcTransportProviderBuilder()
          .setChannelConfigurator(
              new ApiFunction<ManagedChannelBuilder, ManagedChannelBuilder>() {
                @Override
                public ManagedChannelBuilder apply(ManagedChannelBuilder managedChannelBuilder) {
                  return managedChannelBuilder.proxyDetector(
                      new ProxyDetector() {
                        @Nullable
                        @Override
                        public ProxiedSocketAddress proxyFor(SocketAddress socketAddress)
                            throws IOException {
                          return HttpConnectProxiedSocketAddress.newBuilder()
                              .setUsername(PROXY_USERNAME)
                              .setPassword(PROXY_PASSWORD)
                              .setProxyAddress(new InetSocketAddress(PROXY_HOST, PROXY_PORT))
                              .setTargetAddress((InetSocketAddress) socketAddress)
                              .build();
                        }
                      });
                }
              })
          .build();
  CloudTasksSettings cloudTasksSettings =
      CloudTasksSettings.newBuilder()
          .setTransportChannelProvider(transportChannelProvider)
          .build();
  return CloudTasksClient.create(cloudTasksSettings);
}
```