faas | OpenFaaS - Serverless Functions | Function As A Service library

I'm not sure this is supported as I don't see it documented, but I looked at the unit tests for Eleventy and saw many examples of this (https://github.com/11ty/eleventy/tree/master/test). I tried the following and it worked. Note that init an write are both async and I do NOT properly await them, I was just trying to get a simple example:

Nomad jobs listen on a specific host/port pair.

You might want to ssh into the server and run docker ps to see what host/port pair the job is listening on.

It's best to use CAS actions for this; however, the table.deleteRows action was not added until Viya 3.5. Promoted tables were originally meant to be basically immutable: when a table is up and promoted in CAS for everyone, it generally should only be appended to with good data. Bad data, of course, gets in to production systems sometimes and it needs to be modified.

Since you need to delete rows, the safest way would be to create a copy of it in CASUSER, drop the old table, then promote the updated one. It's likely that their CAS cluster has more than enough memory to do this.

Double-check if it's partitioned or ordered a specific way before doing this. You can add the partition and order statements to your dataset options. If you need to save the table to persistent storage, use the save statement in proc casutil as well.

With this method, all changes are done only in CAS.

WCF or the Windows Communication Foundation, is another framework, this time for writing and consuming services. These are either web services, or other, e.g. TCP based services, even MSMQ based services. This is, in my opinion, what you should be looking at for exposing your back-end. WCF provides you the ability to easily specify a contract and implementation, while leaving the hosting of the service and the instantiation to IIS (IIS being Microsoft's web server, which is also running under the covers on Azure).

Azure, towards you, is a hosting provider. It helps you scale your application servers based on demand (e.g. number of mobile clients downloading & installing your application).

A little marketing speak: Azure lowers your cost of ownership for your own solutions because it takes away the initial investment in firstly figuring out (guessing) the amount of hardware you need and then building/renting a data center and/or hardware. It also provides some form of middleware for your applications, like AppFabric, so that they can communicate in the "cloud" a bit better. You also get load balancing on Azure, distributed hosting (e.g. Europe datacenters, USA datacenters...), fail safe mechanism already in place (automatic instance instantiation if one were to fail) and obviously, pay as you go & what you use benefits.

Here is the reference: Introduction to Azure Functions, Azure and WCF

The OpenFaas is equiped with autoscaler itself with its own alert manager:

OpenFaaS ships with a single auto-scaling rule defined in the mounted configuration file for AlertManager. AlertManager reads usage (requests per second) metrics from Prometheus in order to know when to fire an alert to the API Gateway.

After some reading I found out that OpenFaas autoscaler/alertmanger is more focused on API hit rates whereas Kubernetes HPA is more focused on CPU and memory usage so it all depends on what you exactly need.

So you have two different annotations for two different tools for scaling. The deployment.kubernetes.io/max-replicas=2 is for Kubernetes HPA and com.openfaas.scale.max: 1 is for the OpenFaas autoscaler.

The OpenFaas has a great example of how you can use HPA instead built in scaler. You can also use custom Prometheus metrics with HPA as described here.

Since you have different API Gateways for your different clients, you can use Stage Variables.

For example, lets imagine you have two clients called Awesome Ales and Great Gins. For both you have two stages each, called Staging and Production. You want to use a different RDS database for each client and each stage.

Now you need to set the names of those names as stage variable for their respective clients and stages and then in your Lambda, you read the name of the stage variable from the Lambdas event.

If you use proxy integration for the Lambda and your stage variable is called dbname, it will be accessible as event.stageVariables.dbname:

Azure Container Instances don't have a wehbook or HTTP trigger that will start them. However, you could use an Azure Function or Logic App that would effectively run az container start for you and then call THAT with HTTP. With either of those approaches, you'd have to setup some IAM permissions to give the Function or Logic App permissions to the ACI resource to start it.

One approach would be to:

1. Create an Azure Function with an HTTP trigger and a managed identity
2. Give the Managed identity contributor access to ACI container group
3. Run az container start or the equivalent REST call inside the function to start the ACI container
4. Call the Azure function (using the function token) to start the container.

There is no problem with a data structure like this(Array of Array of Objects) when we are working with JSON.

Try this in your code:

When the documentation talks about "Flask's built-in server", it's talking about the server that you get when you run the command flask run (or in older applications running a command like python my_application.py with a line in the main function like app.run()).

When you run flask on Lambda (using Zappa or another solution like aws-wsgi or serverless-wsgi), you're not using Flask's built-in server or any server at all; the wrapper code (in Zappa or anything else) is translating the lambda event to a call to your WSGI application.

Since there is no actual WSGI server, it's not possible to use Gunicorn, uWGSI, etc (well, it may be possible, but it would be very convoluted).