Use HTTP connection pooling

Stay organized with collections Save and categorize content based on your preferences.

Shows how to recycle HTTP connections using HTTP connection pools.

Explore further

For detailed documentation that includes this code sample, see the following:

Code sample


// Package http provides a set of HTTP Cloud Functions samples.
package http

import (


var urlString = ""

// client is used to make HTTP requests with a 10 second timeout.
// http.Clients should be reused instead of created as needed.
var client = &http.Client{
	Timeout: 10 * time.Second,

func init() {
	functions.HTTP("MakeRequest", MakeRequest)

// MakeRequest is an example of making an HTTP request. MakeRequest uses a
// single http.Client for all requests to take advantage of connection
// pooling and caching. See
func MakeRequest(w http.ResponseWriter, r *http.Request) {
	resp, err := client.Get(urlString)
	if err != nil {
		http.Error(w, "Error making request", http.StatusInternalServerError)
	if resp.StatusCode != http.StatusOK {
		msg := fmt.Sprintf("Bad StatusCode: %d", resp.StatusCode)
		http.Error(w, msg, http.StatusInternalServerError)
	fmt.Fprintf(w, "ok")


import java.time.Duration;

public class SendHttpRequest implements HttpFunction {

  // Create a client with some reasonable defaults. This client can be reused for multiple requests.
  // ( also pools connections automatically by default.)
  private static HttpClient client =

  public void service(HttpRequest request, HttpResponse response)
      throws IOException, InterruptedException {
    // Create a GET sendHttpRequest to ""
    String url = "";
    var getRequest =;

    // Send the sendHttpRequest using the client
    var getResponse = client.send(getRequest, BodyHandlers.ofString());

    // Write the results to the output:
    var writer = new PrintWriter(response.getWriter());
    writer.printf("Received code '%s' from url '%s'.", getResponse.statusCode(), url);


const fetch = require('node-fetch');

const http = require('http');
const https = require('https');

const functions = require('@google-cloud/functions-framework');

const httpAgent = new http.Agent({keepAlive: true});
const httpsAgent = new https.Agent({keepAlive: true});

 * HTTP Cloud Function that caches an HTTP agent to pool HTTP connections.
 * @param {Object} req Cloud Function request context.
 * @param {Object} res Cloud Function response context.
functions.http('connectionPooling', async (req, res) => {
  try {
    // TODO(optional): replace this with your own URL.
    const url = '';

    // Select the appropriate agent to use based on the URL.
    const agent = url.includes('https') ? httpsAgent : httpAgent;

    const fetchResponse = await fetch(url, {agent});
    const text = await fetchResponse.text();

    res.status(200).send(`Data: ${text}`);
  } catch (err) {
    res.status(500).send(`Error: ${err.message}`);


import functions_framework
import requests

# Create a global HTTP session (which provides connection pooling)
session = requests.Session()

def connection_pooling(request):
    HTTP Cloud Function that uses a connection pool to make HTTP requests.
        request (flask.Request): The request object.
        The response text, or any set of values that can be turned into a
        Response object using `make_response`

    # The URL to send the request to
    url = ''

    # Process the request
    response = session.get(url)
    return 'Success!'

What's next

To search and filter code samples for other Google Cloud products, see the Google Cloud sample browser.