faas | Failure as a Service | Testing library

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).

The documentation shows how to create an endpoint without the help of an Express app, router, or middleware:

You're right, it may be a bit confusing if you're getting started on it. Initially Serverless was used to describe

-Backend as a Service

-Functions as a Service

more info: https://www.martinfowler.com/articles/serverless.html

Now, many things evolved to Serverless approach. You can pick the latest announcements of SQL Database Serverless, Cosmos Db Serverless etc. So in summary, just consider that serverless is something triggered by event, and billed according to compute resources used and which you don't handle/manage the underlying infrastructure.

-IaaS is not Serverless

-PaaS is not Serverless

-SaaS is not Serverless (but can be implemented using Serverless)

-CaaS can be serverless

-FaaS is serverless