Configuration of the proxied HTTP request version.

.gitignore

@@ -353,3 +353,9 @@ MigrationBackup/
 
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
+
+# Rider 
+.idea/
+
+# nohup
+nohup.out

samples/ReverseProxy.Code.Sample/CustomConfigFilter.cs

@@ -15,15 +15,16 @@ public class CustomConfigFilter : IProxyConfigFilter
         public Task ConfigureClusterAsync(Cluster cluster, CancellationToken cancel)
         {
             // How to use custom metadata to configure clusters
-            if (cluster.Metadata?.TryGetValue("CustomHealth", out var customHealth) ?? false
+            if (cluster.Metadata != null
+                && cluster.Metadata.TryGetValue("CustomHealth", out var customHealth)
                 && string.Equals(customHealth, "true", StringComparison.OrdinalIgnoreCase))
             {
                 cluster.HealthCheck ??= new HealthCheckOptions { Active = new ActiveHealthCheckOptions() };
                 cluster.HealthCheck.Active.Enabled = true;
                 cluster.HealthCheck.Active.Policy = HealthCheckConstants.ActivePolicy.ConsecutiveFailures;
             }
 
-            // Or wrap the meatadata in config sugar
+            // Or wrap the metadata in config sugar
             var config = new ConfigurationBuilder().AddInMemoryCollection(cluster.Metadata).Build();
             if (config.GetValue<bool>("CustomHealth"))
             {

src/ReverseProxy/Abstractions/ClusterDiscovery/Contract/Cluster.cs

@@ -55,6 +55,11 @@ public sealed class Cluster : IDeepCloneable<Cluster>
         /// </summary>
         public ProxyHttpClientOptions HttpClient { get; set; }
 
+        /// <summary>
+        /// Options of an outgoing HTTP request.
+        /// </summary>
+        public ProxyHttpRequestOptions HttpRequest { get; set; }
+
         /// <summary>
         /// The set of destinations associated with this cluster.
         /// </summary>
@@ -78,6 +83,7 @@ Cluster IDeepCloneable<Cluster>.DeepClone()
                 SessionAffinity = SessionAffinity?.DeepClone(),
                 HealthCheck = HealthCheck?.DeepClone(),
                 HttpClient = HttpClient?.DeepClone(),
+                HttpRequest = HttpRequest?.DeepClone(),
                 Destinations = Destinations.DeepClone(StringComparer.OrdinalIgnoreCase),
                 Metadata = Metadata?.DeepClone(StringComparer.OrdinalIgnoreCase),
             };
@@ -103,6 +109,7 @@ internal static bool Equals(Cluster cluster1, Cluster cluster2)
                 && SessionAffinityOptions.Equals(cluster1.SessionAffinity, cluster2.SessionAffinity)
                 && HealthCheckOptions.Equals(cluster1.HealthCheck, cluster2.HealthCheck)
                 && ProxyHttpClientOptions.Equals(cluster1.HttpClient, cluster2.HttpClient)
+                && ProxyHttpRequestOptions.Equals(cluster1.HttpRequest, cluster2.HttpRequest)
                 && CaseInsensitiveEqualHelper.Equals(cluster1.Destinations, cluster2.Destinations, Destination.Equals)
                 && CaseInsensitiveEqualHelper.Equals(cluster1.Metadata, cluster2.Metadata);
         }

src/ReverseProxy/Abstractions/ClusterDiscovery/Contract/ProxyHttpRequestOptions.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Net.Http;
+
+namespace Microsoft.ReverseProxy.Abstractions
+{
+    public sealed class ProxyHttpRequestOptions
+    {
+        public TimeSpan? RequestTimeout { get; set; }
+
+        public Version Version { get; set; }
+
+#if NET
+        public HttpVersionPolicy VersionPolicy { get; set; }
+#endif
+
+        internal ProxyHttpRequestOptions DeepClone()
+        {
+            return new ProxyHttpRequestOptions
+            {
+                RequestTimeout = RequestTimeout,
+                Version = Version,
+#if NET
+                VersionPolicy = VersionPolicy,
+#endif
+            };
+        }
+
+        internal static bool Equals(ProxyHttpRequestOptions options1, ProxyHttpRequestOptions options2)
+        {
+            if (options1 == null && options2 == null)
+            {
+                return true;
+            }
+
+            if (options1 == null || options2 == null)
+            {
+                return false;
+            }
+
+            return options1.RequestTimeout == options2.RequestTimeout
+                   && options1.Version == options2.Version
+#if NET
+                   && options1.VersionPolicy == options2.VersionPolicy
+#endif
+                ;
+        }
+    }
+}

src/ReverseProxy/Configuration/ConfigurationConfigProvider.cs

@@ -147,6 +147,7 @@ private Cluster Convert(string clusterId, ClusterData data)
                 SessionAffinity = Convert(data.SessionAffinity),
                 HealthCheck = Convert(data.HealthCheck),
                 HttpClient = Convert(data.HttpClient),
+                HttpRequest = Convert(data.HttpRequest),
                 Metadata = data.Metadata?.DeepClone(StringComparer.OrdinalIgnoreCase)
             };
             foreach(var destination in data.Destinations)
@@ -353,6 +354,30 @@ private ProxyHttpClientOptions Convert(ProxyHttpClientData data)
             };
         }
 
+        private ProxyHttpRequestOptions Convert(ProxyHttpRequestData data)
+        {
+            if (data == null)
+            {
+                return null;
+            }
+
+            // Parse version only if it contains any characters; otherwise, leave it null.
+            var version = default(Version);
+            if (!string.IsNullOrEmpty(data.Version))
+            {
+                version = Version.Parse(data.Version + (data.Version.Contains('.') ? "" : ".0"));
+            }
+
+            return new ProxyHttpRequestOptions
+            {
+                RequestTimeout = data.RequestTimeout,
+                Version = version,
+#if NET
+                VersionPolicy = data.VersionPolicy,
+#endif
+            };
+        }
+
         private static Destination Convert(DestinationData data)
         {
             if (data == null)

src/ReverseProxy/Configuration/Contract/ClusterData.cs

@@ -49,6 +49,11 @@ public sealed class ClusterData
         /// </summary>
         public ProxyHttpClientData HttpClient { get; set; }
 
+        /// <summary>
+        /// Options of an outgoing HTTP request.
+        /// </summary>
+        public ProxyHttpRequestData HttpRequest { get; set; }
+
         /// <summary>
         /// The set of destinations associated with this cluster.
         /// </summary>

src/ReverseProxy/Configuration/Contract/ProxyHttpRequestData.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Net.Http;
+
+namespace Microsoft.ReverseProxy.Configuration.Contract
+{
+    /// <summary>
+    /// Outgoing request configuration.
+    /// </summary>
+    public class ProxyHttpRequestData
+    {
+        /// <summary>
+        /// Timeout for the outgoing request.
+        /// Default is 100 seconds.
+        /// </summary>
+        public TimeSpan? RequestTimeout { get; set; }
+
+        /// <summary>
+        /// HTTP version for the outgoing request.
+        /// Default is HTTP/2.
+        /// </summary>
+        public string Version { get; set; }
+
+#if NET
+        /// <summary>
+        /// Version policy for the outgoing request.
+        /// Defines whether to upgrade or downgrade HTTP version if possible.
+        /// Default is <c>RequestVersionOrLower</c>.
+        /// </summary>
+        public HttpVersionPolicy VersionPolicy { get; set; }
+#endif
+    }
+}

src/ReverseProxy/Middleware/ProxyInvokerMiddleware.cs

@@ -8,6 +8,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 using Microsoft.ReverseProxy.Abstractions.Telemetry;
+using Microsoft.ReverseProxy.RuntimeModel;
 using Microsoft.ReverseProxy.Service.Proxy;
 using Microsoft.ReverseProxy.Utilities;
 
@@ -80,6 +81,19 @@ public async Task Invoke(HttpContext context)
                 Transforms = routeConfig.Transforms,
             };
 
+            var requestOptions = reverseProxyFeature.ClusterConfig.HttpRequestOptions;
+            if (requestOptions.RequestTimeout != default)
+            {
+                proxyOptions.RequestTimeout = requestOptions.RequestTimeout;
+            }
+            if (requestOptions.Version != default)
+            {
+                proxyOptions.Version = requestOptions.Version;
+            }
+#if NET
+            proxyOptions.VersionPolicy = requestOptions.VersionPolicy;
+#endif
+
             try
             {
                 cluster.ConcurrencyCounter.Increment();

src/ReverseProxy/Service/Config/ConfigValidator.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Authorization;
@@ -118,6 +119,7 @@ public ValueTask<IList<Exception>> ValidateClusterAsync(Cluster cluster)
 
             ValidateSessionAffinity(errors, cluster);
             ValidateProxyHttpClient(errors, cluster);
+            ValidateProxyHttpRequest(errors, cluster);
             ValidateActiveHealthCheck(errors, cluster);
             ValidatePassiveHealthCheck(errors, cluster);
 
@@ -322,6 +324,23 @@ private void ValidateProxyHttpClient(IList<Exception> errors, Cluster cluster)
             }
         }
 
+        private void ValidateProxyHttpRequest(IList<Exception> errors, Cluster cluster)
+        {
+            if (cluster.HttpRequest == null)
+            {
+                // Proxy http request options are not set.
+                return;
+            }
+
+            if (cluster.HttpRequest.Version != null &&
+                cluster.HttpRequest.Version != HttpVersion.Version10 &&
+                cluster.HttpRequest.Version != HttpVersion.Version11 &&
+                cluster.HttpRequest.Version != HttpVersion.Version20)
+            {
+                errors.Add(new ArgumentException($"Outgoing request version '{cluster.HttpRequest.Version}' is not any of supported HTTP versions (1.0, 1.1 and 2)."));
+            }
+        }
+
         private void ValidateActiveHealthCheck(IList<Exception> errors, Cluster cluster)
         {
             if (cluster.HealthCheck == null || cluster.HealthCheck.Active == null || !cluster.HealthCheck.Active.Enabled)

src/ReverseProxy/Service/HealthChecks/DefaultProbingRequestFactory.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Net;
 using System.Net.Http;
 using Microsoft.AspNetCore.Http.Extensions;
 using Microsoft.ReverseProxy.RuntimeModel;
@@ -15,7 +16,18 @@ public HttpRequestMessage CreateRequest(ClusterConfig clusterConfig, Destination
             var probePath = clusterConfig.HealthCheckOptions.Active.Path;
             UriHelper.FromAbsolute(probeAddress, out var destinationScheme, out var destinationHost, out var destinationPathBase, out _, out _);
             var probeUri = UriHelper.BuildAbsolute(destinationScheme, destinationHost, destinationPathBase, probePath, default);
-            return new HttpRequestMessage(HttpMethod.Get, probeUri) { Version = ProtocolHelper.Http2Version };
+            var version = HttpVersion.Version20;
+            if (clusterConfig.HttpRequestOptions.Version != default)
+            {
+                version = clusterConfig.HttpRequestOptions.Version;
+            }
+            return new HttpRequestMessage(HttpMethod.Get, probeUri)
+            {
+                Version = version,
+#if NET
+                VersionPolicy = clusterConfig.HttpRequestOptions.VersionPolicy
+#endif
+            };
         }
     }
 }

src/ReverseProxy/Service/Management/ProxyConfigManager.cs

@@ -4,6 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
@@ -311,6 +313,13 @@ private void UpdateRuntimeClusters(IList<Cluster> newClusters)
                                     settings: newCluster.SessionAffinity?.Settings as IReadOnlyDictionary<string, string>),
                                 httpClient,
                                 newClusterHttpClientOptions,
+                                new ClusterProxyHttpRequestOptions(
+                                    requestTimeout: newCluster.HttpRequest?.RequestTimeout ?? TimeSpan.FromSeconds(100),
+                                    version: newCluster.HttpRequest?.Version ?? HttpVersion.Version20
+#if NET
+                                    , versionPolicy: newCluster.HttpRequest?.VersionPolicy ?? HttpVersionPolicy.RequestVersionOrLower
+#endif
+                                    ),
                                 (IReadOnlyDictionary<string, string>)newCluster.Metadata);
 
                         if (currentClusterConfig == null ||

src/ReverseProxy/Service/RuntimeModel/ClusterConfig.cs

@@ -16,7 +16,7 @@ namespace Microsoft.ReverseProxy.RuntimeModel
     /// <remarks>
     /// All members must remain immutable to avoid thread safety issues.
     /// Instead, instances of <see cref="ClusterConfig"/> are replaced
-    /// in ther entirety when values need to change.
+    /// in their entirety when values need to change.
     /// </remarks>
     public sealed class ClusterConfig
     {
@@ -29,6 +29,7 @@ public ClusterConfig(
             ClusterSessionAffinityOptions sessionAffinityOptions,
             HttpMessageInvoker httpClient,
             ClusterProxyHttpClientOptions httpClientOptions,
+            ClusterProxyHttpRequestOptions httpRequestOptions,
             IReadOnlyDictionary<string, string> metadata)
         {
             _cluster = cluster;
@@ -37,6 +38,7 @@ public ClusterConfig(
             SessionAffinityOptions = sessionAffinityOptions;
             HttpClient = httpClient;
             HttpClientOptions = httpClientOptions;
+            HttpRequestOptions = httpRequestOptions;
             Metadata = metadata;
         }
 
@@ -48,6 +50,8 @@ public ClusterConfig(
 
         public ClusterProxyHttpClientOptions HttpClientOptions { get; }
 
+        public ClusterProxyHttpRequestOptions HttpRequestOptions { get; }
+
         /// <summary>
         /// An <see cref="HttpMessageInvoker"/> that used for proxying requests to an upstream server.
         /// </summary>

src/ReverseProxy/Service/RuntimeModel/ClusterProxyHttpRequestOptions.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Net.Http;
+
+namespace Microsoft.ReverseProxy.RuntimeModel
+{
+    public readonly struct ClusterProxyHttpRequestOptions
+    {
+        public ClusterProxyHttpRequestOptions(
+            TimeSpan requestTimeout,
+            Version version
+#if NET
+            , HttpVersionPolicy versionPolicy
+#endif
+        )
+        {
+            RequestTimeout = requestTimeout;
+            Version = version;
+#if NET
+            VersionPolicy = versionPolicy;
+#endif
+        }
+
+        public TimeSpan RequestTimeout { get; }
+
+        public Version Version { get; }
+
+#if NET
+        public HttpVersionPolicy VersionPolicy { get; }
+#endif
+    }
+}

test/ReverseProxy.Tests/Abstractions/ClusterDiscovery/Contract/ClusterTests.cs

@@ -26,6 +26,7 @@ public void DeepClone_Works()
                 LoadBalancing = new LoadBalancingOptions(),
                 HealthCheck = new HealthCheckOptions(),
                 HttpClient = new ProxyHttpClientOptions(),
+                HttpRequest = new ProxyHttpRequestOptions(),
                 Metadata = new Dictionary<string, string>
                 {
                     { "key", "value" },