Hazelcast provide a distributed executor service that can be used for CPU-bound applications running on the cluster. I want to know about Hazelcast alternative that is agent based and provide elastic executor service that is agent oriented and shrinks and grow itself. Kindly suggest me the frameworks or libraries that provide agent oriented thread pool.
Related
I found the mention of an agent node in the aks documentation but i'm not finding the defition of it. can anyone please explain it to ? also want to know if is it an azure concept or a kubernetes concept.
Regards,
In Kubernetes the term node refers to a compute node. Depending on the role of the node it is usually referred to as control plane node or worker node. From the docs:
A Kubernetes cluster consists of a set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node.
The worker node(s) host the Pods that are the components of the application workload. The control plane manages the worker nodes and the Pods in the cluster. In production environments, the control plane usually runs across multiple computers and a cluster usually runs multiple nodes, providing fault-tolerance and high availability.
Agent nodes in AKS refers to the worker nodes (which should not be confused with the Kubelet, which is the primary "node agent" that runs on each worker node)
VM scale set can be used to create multiple VM's based on the business requirement and, Also, Azure batch is also used to execute job in multiple VM's.
What is the exact difference between Azure Batch and VM Scale set?
Azure Batch is a Platform as a Service offering that has an entire plaform for scheduling, submitting tasks and obtaining their results. Jobs and tasks are submitted using Node pools. Node pools can be comprised of VMSS compute resourses.
Whereas a VMSS is an Infrastructure as a Service that provides compute resources for any intended purposes. While you can spin up your own VMSS for running tasks, you would have to also implement your own job, task and compute coordinator service around it in order to simulate the Azure Batch service offerings.
At a high-level, Azure Batch provides two fundamental pieces for scheduling Batch and HPC workloads in the cloud:
Managed infrastructure
Cloud-native job scheduling
Azure Batch presents infrastructure at a managed layer "above" VMSS and CloudServices. Azure Batch orchestrates the pieces underneath to provide a concept called Batch pools, which provide potentially higher scale (as multiple deployments can be orchestrated together transparently) and higher resiliency to failures as Batch automatically recovers virtual machines or cloud service instances which have degraded.
Additionally, and just as important, Azure Batch provides cloud-native job scheduling. This portion is fully managed, i.e., you don't have to run a scheduler yourself. In a nutshell, Azure Batch provides concepts for job queues and tasks which you can define within the programmatic (API/SDK) or tooling that is available. Azure Batch operates on these concepts to execute the work you define (e.g., a command-line with dependencies or a Docker container); tasks can even span multiple nodes (e.g., MPI jobs). Azure Batch has the ability to retry these tasks if they fail on different nodes within a pool. Azure Batch provides an autoscale system that allows you to dynamically resize your infrastructure (Batch pools) that respond to node metrics and the number of jobs/tasks executing in the system.
Please refer to the technical overview as a starting point.
azure batch intent is to run jobs, vmss workloads. technically they do overlap a fair bit, but job is something rather short lived\bursty, whereas workload has to be working all the time
VM Scaleset is used to provide automatic scaling for an application and load balancing of traffic.VM Scale sets are good for running web applications/api based workloads where automatic scaling of the applications is handled and traffic load balancing is done.
Azure Batch is for tasks, scheduling jobs, running intrinsically parallel and tightly coupled workloads. It can provide scaling and load balancing of different nodes/VM that would be used for performing a high computation job. It would probably not be a suitable target for long-running services. A common scenario for Batch involves scaling out intrinsically parallel work, such as the rendering of images for 3D scenes, on a pool of compute nodes.
I'm submitting Java runnables to hazelcast executor service, the runnables need access to specific business objects and also to hazelcast client.
Is there any way to deploy a hazelcast cluster on hazelcast cloud with specific dependencies?
#newlogic, according to Hazelcast Cloud Documentation, User Code Deployment feature is enabled. All you need to do is to enable it on the client as well & configure it, as documented here: https://docs.hazelcast.org/docs/latest/manual/html-single/index.html#client-user-code-deployment-beta
We are on Azure since 2010 and had a great benefit from a performance and reliability in our application. Azure offers a lot of enterprise-level services and I think that the new "Azure Service Fabric" is great.
What I cannot understand by reading the documentation is the approach on migrating an "old" Cloud Service to the new Service Fabric. Why do we want to migrate? For horizontal scaling and more reliability.
Currently we have a single-instance cloud service, that spins up a lot of subservices. Those subservices are great candidates for microservices. The only problem is that some of these subservices are "runners", i.e. they just cycle on our users database and decide whether an operation (service) has to be run for a particular user or not.
How would you migrate a service like this considering that more than one instance may run this service?
Thanks
First thing to keep in mind is that once a service is started it keeps running, and his lifecycle and uptime is controlled by Service Fabric (ex: it will restart it automatically if it crashes). Second thing to keep in mind is that you will end-up with multiple instances of the service running at the same time (on different nodes), so they will end-up doing the exact same thing on different nodes of your cluster.
Your first reflex could be to have one stateless service kind/instance per runner "subservice" that keeps running and leverage the RunAsync (https://learn.microsoft.com/en-us/azure/service-fabric/service-fabric-reliable-services-advanced-usage). Personally, I wouldn't take that approach, since this could then require some kind of synchronization between services to prevent useless concurrency, since they do the exact same thing independently.
A better approach would be to have your runner services need to run only once in a while when requested by the "main" service acting as an orchestrator, you could have a Queue based approach where the "main" service submit tasks (messages) to be processed by the runners, who are listening concurrently on the same Queue, making sure that maximum one service instance would complete the task.
For the Queue, think Service Bus or Reliable Concurrent Queue (https://learn.microsoft.com/enus/dotnet/api/microsoft.servicefabric.data.collections.preview.ireliableconcurrentqueue-1).
I was looking for configure the thread pool by application instead of profile. Basically, to avoid the unavailability of threads for most important application that share the profile with application that can run in background.
Is there any configuration thread pools by application instead of profile?
The best would be to use a dedicated thread pool for the critical application.
However in order to achieve that you need to use a separate host-port combination for that particular application.
That is because a web threads pool is associated with a web container transport chain and a transport chain is determined by a host-port pair.