use-http | 🐶 React hook for making isomorphic http requests | Frontend Framework library

But, if I add it as a dependency (for good practice purposes), the hook runs continuously and I get recurring console.log statements. Could someone please explain why this is happening?

Because sendRequest is a function which is re created each time the component is re-rendered, hence, it is different on each render. Because of that, when it is listed as a dependency, useEffect re-runs. Consider using useCallback and wrapping sendRequest using it.

Consider re-rendering of a component same as the function being re-invoked, hence you are creating all the variables or functions inside it from scratch (except cases when React takes care to retain value of your variable across re-renders; this happens with variables from state for example).

But what about Azure Service Bus? There is nothing like an AzureServiceBusFactory or so and adding the AzureServiceBus as a Singleton would not be a good idea, because the configuration should be different on each call.

It is actually the other way round. Service Bus team recommends that connection to your Service Bus should be registered as Singleton only using ServiceBusClientBuilderExtensions and should not be closed or disposed after every operation.

From this link:

The Service Bus objects that interact with the service, such as ServiceBusClient, ServiceBusSender, ServiceBusReceiver, and ServiceBusProcessor, should be registered for dependency injection as singletons (or instantiated once and shared). ServiceBusClient can be registered for dependency injection with the ServiceBusClientBuilderExtensions.

We recommend that you don't close or dispose these objects after sending or receiving each message. Closing or disposing the entity-specific objects (ServiceBusSender/Receiver/Processor) results in tearing down the link to the Service Bus service. Disposing the ServiceBusClient results in tearing down the connection to the Service Bus service.

Please see this link for complete recommendations from Service Bus team: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-performance-improvements?tabs=net-standard-sdk-2.

After further reproduction I've noticed that in the question there is a miss-match between the NGINX Ingress controllers.

There are 2 similarly named Ingress controllers:

• Github.com: NginxInc: Kubernetes Ingress - for this purpose let's name it: nginx-inc
• Github.com: Kubernetes: Ingress Nginx - for this purpose let's name it: nginx

This are 2 separate products where the differences are explained here:

• Github.com: NginxInc: Kubernetes Ingress: Docs: Nginx ingress controllers

Due to this Configmap key:

• use-http2: "true"

I've incorrectly assumed that we are talking about the nginx where in fact it was the nginx-inc (I've missed the link of $ helm repo add). This field is specific to the nginx and will not work with the nginx-inc.

I've managed to find a way to enable the HTTP/2 support with the nginx-inc. Change:

• from: use-http2: "true"
• to: http2: "true"

More explanation can be found here:

• Docs.nginx.com: Nginx Ingress Controller: Configuration: Global configuration: Configmap resource: Listeners

Below part is more of a general approach to the support of HTTP/2 on GKE with Ingress.

A side note!

Even without the tls part in the YAML manifest it's possible to use HTTPS due to the Fake Ingress Controller certificate

As pointed in the following github issue:

aledbf commented on 28 Mar 2019

NGINX does not support HTTP/1.x and HTTP/2 at the same time on a cleartext (non-TLS) port. That's the reason why it works only when HTTPS is used.

-- Github.com: Kubernetes: Ingress nginx: Issue: HTTP2 support

As stated to enable HTTP/2 you will need to have the tls part (certificate) configured in your Ingress resource.

Here you can find the documentation to help you with the process:

• Kubernetes.github.io: Ingress nginx: Examples: TLS termination

I've used your setup on the GKE version 1.20.5-gke.2000 (the Helm part) and here is what I found.

Querying the external IP of your Ingress controller with HTTP request will allow you to use HTTP/1.1.

After I've configured the certificate to use with the Ingress resource (and domain name), I could get the response stating that I'm using HTTP/2:

You can check it with various measures like cURL or online HTTP/2 test sites:

• curl -v -k https://DOMAIN.NAME

Based on Jeremy's comment on my question, I created a new class that I derive from the generated one. It doesn't add any new functionality but it does add a constructor with strongly typed parameters. I still use the base class that handles the security part for me but now I use the DI engine in a way that is recommended by Microsoft.

.NET Core and therefore also .NET 5 supports various HttpHandlers. The SocketsHttpHandler is used to configure a HttpClient to use the .NET internal socket implementation (not relying on WinHttp).

Since .NET 5 you can use the ConnectCallback of the SocketsHttpHandler to configure how the connection should be established like this:

The framework will use ITypedHttpClientFactory to create the HttpClient to be injected into the typed client. This is happening under the hood when the typed client is configured like so:

The right way of doing it, using the requests module, should look like this:

You should follow standard best-practices when using HttpClient within Orleans. The sample is creating a new one for simplicity of exposition, not as an indicator of best practices. A PR to change the sample documentation to use IHttpClientFactory (for example) would likely be accepted.

You do not need a GrainService to call into HTTP services from your grain: you can inject the required dependencies (IHttpClientFactory or your typed client) and call HTTP services directly from grain code.

Regarding the question on the purpose of GrainService and GrainServiceClient, GrainService is a special service which is intended to be accessed from grain code. GrainServices are instantiated on every node in the cluster and each one is given responsibility over a set of grains. As an example, reminders (persistent timers) in Orleans are implemented using GrainServices. The LocalReminderService on each node takes responsibility for a set of grains and will wake those grains up when their reminders are due. GrainServiceClient is used by grains to access the GrainService instance which is responsible for the calling grain. The documentation explains more here: https://dotnet.github.io/orleans/Documentation/grains/grainservices.html

I would avoid using GrainService unless you find a use case which it fits closely.

You have not posted your code to review your issue. However, you should consider two things in Google Drive requests. First you should use Google APIs to process the requests. This means, you'll have to have an authenticated requests through OAuth2 protocols.

If you're using their NuGets, then you can simply use the DriveService to get the file size.