“Expressive Calling” could make it more likely that your urgent phone call gets answered
Table of Contents
You might think that the most boring apps on Android and iOS are their respective phone apps. While they are developed to allow you to make a phone call,put together a contacts list,and collect voice mail,there is nothing terribly exciting there,right? Now it appears that 9to5Google has discovered that Google is working on a new feature for the Phone by Google app titled “Expressive Calling” and codenamed “expresso.”
According to strings of code discovered on beta version 201 of the Phone by Google app, which was uploaded to the Google Play Store, “Expressive Calling” will allow someone with the feature enabled to tell the person on the other end of the call why he is getting in touch with him.It will also allow the caller to tell the person he rang that he is calling over an urgent matter. You can even specify a reason for your call choosing among the following:
* “Catch up”
* “News to share”
* “Quick question”
* “It’s urgent!”
If you choose “It’s urgent” as the reason for your call, the party at the other end will hear a sound. An “It’s urgent” designation will also be able to “penetrate” through an enabled “Do not Disturb” setting. If you make a call that you’ve labeled “urgent” via the feature and it is not answered, the other party will receive a notification saying “Missed Urgent Call.” The person that you are trying to reach will receive this message on his incoming call screen and by a notification. for the “Expressive Calling” feature to work, the user will need to grant SMS permission to the Phone by Google app.
“Expressive Calling” could be exclusive to Pixel handsets
obviously, this new feature has not been officially announced, and it may never be. If Google does launch “Expressive Calling” is expected to be
“`html
The Ultimate Guide to Kubernetes Autoscaling
Published: 2025/11/23 05:01:49
Kubernetes autoscaling is essential for modern application deployment. It ensures your applications can handle fluctuating traffic demands without manual intervention, optimizing resource utilization and cost efficiency. this guide provides a extensive overview of Kubernetes autoscaling, covering its benefits, different types, configuration, and best practices.
Why Kubernetes Autoscaling Matters
In today’s dynamic environments, applications experience unpredictable spikes in traffic. Manually adjusting resources to meet these demands is time-consuming, error-prone, and frequently enough insufficient. Kubernetes autoscaling solves this problem by automatically adjusting the number of pods based on observed metrics. This leads to several key benefits:
- Improved Resource Utilization: Scale up when needed, scale down when not, minimizing wasted resources.
- Enhanced Application Availability: Maintain performance during peak loads, preventing service disruptions.
- Cost Optimization: Reduce cloud spending by only using the resources you actually need.
- Reduced operational Overhead: Automate scaling tasks, freeing up your team to focus on other priorities.
The Core Concepts: HPA and VPA
Kubernetes offers two primary autoscaling mechanisms:
- Horizontal Pod autoscaler (HPA): Automatically scales the number of pods in a deployment or replica set based on observed CPU utilization, memory usage, or custom metrics.
- Vertical Pod Autoscaler (VPA): Automatically adjusts the CPU and memory requests and limits of individual pods.
Understanding the difference is crucial.HPA focuses on how many pods, while VPA focuses on how much resource each pod needs.
Horizontal Pod Autoscaling (HPA) in Detail
HPA is the most commonly used autoscaling method. It works by continuously monitoring metrics and comparing them to defined target values. When metrics exceed the target, HPA increases the number of pods. When metrics fall below the target, HPA decreases the number of pods.
Configuring HPA
you can configure HPA using the `kubectl autoscale` command or by defining an HPA resource in a YAML file. Here’s a basic example:
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: my-app-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: my-app
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50
This configuration scales the `my-app` deployment between 2 and 10 replicas, targeting 50% CPU utilization.
HPA metrics
HPA supports various metrics:
- resource metrics (CPU, Memory): Based on pod resource usage.
- Object Metrics (Requests per second): Based on custom metrics exposed by your application. Requires a metrics server like Prometheus.
- External Metrics: Based on metrics from external sources.
Vertical Pod Autoscaling (VPA) in Detail
VPA analyzes the resource usage of your pods over time and recommends appropriate CPU and memory requests and limits. It can operate in different modes:
- Off: VPA only provides recommendations.
- Initial: VPA sets resource requests during pod creation.
- Recreate: VPA updates resource requests and recreates pods to apply the changes.
- Auto: VPA automatically adjusts resource requests and limits, potentially recreating pods.
Configuring VPA
Similar to HPA,VPA is configured using YAML files.Here’s a basic example:
apiVersion: auto.openshift.io/v1
kind: VerticalPodAutoscaler
metadata:
name: my-app-vpa
spec:
targetRef:
apiVersion: apps/v1
kind: deployment
name: my-app
updatePolicy:
autoFailover: true
mode: Auto
This configuration automatically adjusts the CPU and memory requests and limits for the `my-app` deployment.
Combining HPA and VPA
HPA and VPA are complementary. VPA ensures each pod has the right amount of resources, while HPA ensures you have the right number of pods.Using both together can lead to optimal resource utilization and application performance.
“While VPA can significantly improve resource efficiency,it’s notable to carefully consider the disruption caused by pod recreation,especially in production environments. Start with the ‘Off’ or ‘Initial’ modes before moving to ‘Auto’.”
Best Practices for Kubernetes Autoscaling
- Define Realistic Resource Requests and Limits: Accurate requests and limits are crucial for effective autoscaling.
- Monitor Your Autoscaling Configuration: Regularly review HPA and VPA metrics to ensure they are working as expected.
- Use Custom Metrics: Leverage application-specific metrics for more precise scaling.
- Consider Pod Disruption Budgets (PDBs): Protect your application availability during scaling events.
- Test Thoroughly: Simulate peak loads to validate your autoscaling configuration.
FAQ
- Q: What happens if my application doesn’t respond to HPA metrics?
A: Ensure your application is exposing the necessary metrics and that your metrics server is properly configured.
- Q: Can I use HPA with custom metrics from Prometheus?
A: Yes
Related reading