using Google.Cloud.Functions.Framework;
using Google.Cloud.Functions.Hosting;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using System.Net.Http;
using System.Threading.Tasks;
namespace SendHttpRequest
{
// Dependency injection configuration, executed during server startup.
public class Startup : FunctionsStartup
{
public override void ConfigureServices(WebHostBuilderContext context, IServiceCollection services)
{
// Make an HttpClient available to our function via dependency injection.
// There are many options here; see
// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/http-requests
// for more details.
services.AddHttpClient<IHttpFunction, Function>();
}
}
// Function, decorated with the FunctionsStartup attribute to specify the startup class
// for dependency injection.
[FunctionsStartup(typeof(Startup))]
public class Function : IHttpFunction
{
private readonly HttpClient _httpClient;
public Function(HttpClient httpClient) =>
_httpClient = httpClient;
public async Task HandleAsync(HttpContext context)
{
string url = "http://example.com";
using (HttpResponseMessage clientResponse = await _httpClient.GetAsync(url))
{
await context.Response.WriteAsync($"Received code '{(int) clientResponse.StatusCode}' from URL '{url}'.");
}
}
}
}
// Package http provides a set of HTTP Cloud Functions samples.
package http
import (
"fmt"
"net/http"
"time"
)
var urlString = "https://example.com"
// 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,
}
// 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 https://godoc.org/net/http#Client.
func MakeRequest(w http.ResponseWriter, r *http.Request) {
resp, err := client.Get(urlString)
if err != nil {
http.Error(w, "Error making request", http.StatusInternalServerError)
return
}
if resp.StatusCode != http.StatusOK {
msg := fmt.Sprintf("Bad StatusCode: %d", resp.StatusCode)
http.Error(w, msg, http.StatusInternalServerError)
return
}
fmt.Fprintf(w, "ok")
}
import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpResponse.BodyHandlers;
import java.time.Duration;
public class SendHttpRequest implements HttpFunction {
// Create a client with some reasonable defaults. This client can be reused for multiple requests.
// (java.net.httpClient also pools connections automatically by default.)
private static HttpClient client =
HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();
@Override
public void service(HttpRequest request, HttpResponse response)
throws IOException, InterruptedException {
// Create a GET sendHttpRequest to "http://example.com"
String url = "http://example.com";
var getRequest = java.net.http.HttpRequest.newBuilder().uri(URI.create(url)).GET().build();
// 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);
}
}
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Client;
use GuzzleHttp\Psr7\Response;
function makeRequest(ServerRequestInterface $request): ResponseInterface
{
// This sample uses the GuzzleHTTP client
// See its documentation for usage information
// https://docs.guzzlephp.org/en/stable/
// Specify the URL to send requests to
$client = new Client([
'base_uri' => 'https://example.com',
]);
// Send the request
$url_response = $client->get('/');
$function_response = new Response(
$url_response->getStatusCode(),
[], // headers
'' // body
);
return $function_response;
}
def make_request(request):
"""
HTTP Cloud Function that makes another HTTP request.
Args:
request (flask.Request): The request object.
<http://flask.pocoo.org/docs/1.0/api/#flask.Request>
Returns:
The response text, or any set of values that can be turned into a
Response object using `make_response`
<http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
"""
import requests
# The URL to send the request to
url = 'http://example.com'
# Process the request
response = requests.get(url)
response.raise_for_status()
return 'Success!'
