my health extension
Generate formatted bibliographies, citations, and works cited automatically
Create bibliographies and citations quickly and accurately
APA, MLA, Chicago & Harvard styles supported (plus others!)
100% free. No ads, privacy trackers, time limits, or restrictions
Super fast! Be done with citing in minutes, not hours
What is MyBib?
MyBib is a free bibliography and citation generator that makes accurate citations for you to copy straight into your academic assignments and papers.
If you're a student, academic, or teacher, and you're tired of the other bibliography and citation tools out there, then you're going to love MyBib. MyBib creates accurate citations automatically for books, journals, websites, and videos just by searching for a title or identifier (such as a URL or ISBN).
Plus, we're using the same citation formatting engine as professional-grade reference managers such as Zotero and Mendeley, so you can be sure our bibliographies are perfectly accurate in over 9,000 styles -- including APA 6 & 7, Chicago, Harvard, and MLA 7 & 8.
Quick features:
| Styles | APA, MLA, Harvard |
|---|---|
| Sources | Websites, books, journals, newspapers |
| Autocite | Yes |
| Download to | Microsoft Word, Google Docs |
Health and Care Worker visa
You can usually apply to extend your Health and Care Worker visa if all of the following are true:
- you have the same job as when you were given your previous permission to enter or stay in the UK
- your job is in the same occupation code as when you were given your previous permission to enter or stay in the UK
- youre still working for the employer who gave you your current certificate of sponsorship
- you still meet the salary requirements
You must not travel outside of the UK, Ireland, the Channel Islands or the Isle of Man until you get a decision. Your application will be withdrawn if you do.
Your partner and children
Your partner or childs visa will not automatically extend if you extend yours. If they do not extend their visa, it will be valid until its original end date.
They can either apply at the same time as you, or at any time before their current visa expires.
If youre a care worker or senior care worker, your partner and children may not be able to stay in the UK as your dependants when you extend your visa.
If you have a Tier 2 Health and Care Worker visa
Youll have a Tier 2 Health and Care Worker visa if either:
- you applied for a Health and Care Worker visa before 1 December 2020
- you had a Tier 2 (General) work visa which youve extended as a Health and Care Worker visa
If you have this visa, you may be able to meet different eligibility requirements.
If you apply to extend before 1 December 2026, you will still need to meet the salary requirements, but your salary may also include allowances, such as London weighting. Any allowances must be guaranteed for the length of your stay.
If youre a physical scientist
If you were sponsored for your Tier 2 (General) or Health and Care Worker visa before 1 December 2020, the going rate for your job is different.
| Occupation code | Going rate for Health and Care Worker visa | 90% of going rate (for relevant STEM PhD) | 80% of going rate (for relevant non-STEM PhD or immigration salary list occupation) | 70% of going rate (for new entrants) |
|---|---|---|---|---|
| 2114 Physical scientists | 29,000 (13.94 per hour) | 26,100 (12.55 per hour) | 24,750 (11.90 per hour) | 24,750 (11.90 per hour) |
If youve changed job or employer
Youll need to apply to update your visa instead.
Fees
Check how much it costs for your type of visa.
Youll also need to have your biometric information (fingerprints and a photo) taken - theres no fee for this.
Proving your identity and providing supporting documents
As part of your application youll need to prove your identity. How you do this depends on where youre from and the type of passport or resident permit you have.
Youll either:
- use the UK Immigration: ID Check app to scan your identity document - youll also create or sign in to your UK Visas and Immigration (UKVI) account
- give your fingerprints and a photograph (biometric information) at a UK Visa and Citizenship Application Services (UKVCAS) service point - this is to get a biometric residence permit
Youll be told what you need to do when you apply.
Apply to extend your Health and Care Worker visa
Apply for a Skilled Worker visa. Youll be asked if youre applying for a Health and Care Worker visa as part of your application - make sure you choose yes.
You must apply online before your current visa expires.
Once youve started your application, you can save your form and complete it later.
Apply now
Continue your application
You can sign back into your application if youve saved it.
Find out how to sign in to your account.
How long it takes to get a decision
Once youve applied online, proved your identity and provided your documents, youll usually get a decision within 3 weeks.
Youll be contacted if your application will take longer, for example because:
- your supporting documents need to be verified
- you need to attend an interview
- of your personal circumstances, for example if you have a criminal conviction
You may be able to pay to get a faster decision.
After you apply
If you need to change something in your application after youve sent it contact UK Visas and Immigration (UKVI).
You can ask to cancel your application. Youll only get your fee refunded if UKVI has not started processing your application.
Youll get an email or a letter containing the decision on your application. This will explain what you need to do next.
Using Application Health extension with Virtual Machine Scale Sets
Using Application Health extension with Virtual Machine Scale Sets
- Article
Monitoring your application health is an important signal for managing and upgrading your deployment. Azure Virtual Machine Scale Sets provide support for Rolling Upgrades including Automatic OS-Image Upgrades and Automatic VM Guest Patching, which rely on health monitoring of the individual instances to upgrade your deployment. You can also use Application Health Extension to monitor the application health of each instance in your scale set and perform instance repairs using Automatic Instance Repairs.
This article describes how you can use the two types of Application Health extension, Binary Health States or Rich Health States, to monitor the health of your applications deployed on Virtual Machine Scale Sets.
Prerequisites
This article assumes that you're familiar with:
Caution
Application Health Extension expects to receive a consistent probe response at the configured port tcp or request path http/https in order to label a VM as Healthy. If no application is running on the VM, or you're unable to configure a probe response, your VM is going to show up as Unhealthy (Binary Health States) or Unknown (Rich Health States).
Note
Only one source of health monitoring can be used for a Virtual Machine Scale Set, either an Application Health Extension or a Health Probe. If you have both options enabled, you will need to remove one before using orchestration services like Instance Repairs or Automatic OS Upgrades.
When to use the Application Health extension
The Application Health Extension is deployed inside a Virtual Machine Scale Set instance and reports on application health from inside the scale set instance. The extension probes on a local application endpoint and will update the health status based on TCP/HTTP(S) responses received from the application. This health status is used by Azure to initiate repairs on unhealthy instances and to determine if an instance is eligible for upgrade operations.
The extension reports health from within a VM and can be used in situations where an external probe such as the Azure Load Balancer health probes cant be used.
Binary versus Rich Health States
Application Health Extensions has two options available: Binary Health States and Rich Health States. The following table highlights some key differences between the two options. See the end of this section for general recommendations.
| Features | Binary Health States | Rich Health States |
|---|---|---|
| Available Health States | Two available states: Healthy, Unhealthy | Four available states: Healthy, Unhealthy, Initializing, Unknown1 |
| Sending Health Signals | Health signals are sent through HTTP/HTTPS response codes or TCP connections. | Health signals on HTTP/HTTPS protocol are sent through the probe response code and response body. Health signals through TCP protocol remain unchanged from Binary Health States. |
| Identifying Unhealthy Instances | Instances will automatically fall into Unhealthy state if a Healthy signal isn't received from the application. An Unhealthy instance can indicate either an issue with the extension configuration (for example, unreachable endpoint) or an issue with the application (for example, non-200 status code). | Instances will only go into an Unhealthy state if the application emits an Unhealthy probe response. Users are responsible for implementing custom logic to identify and flag instances with Unhealthy applications2. Instances with incorrect extension settings (for example, unreachable endpoint) or invalid health probe responses will fall under the Unknown state2. |
| Initializing state for newly created instances | Initializing state isn't available. Newly created instances may take some time before settling into a steady state. | Initializing state allows newly created instances to settle into a steady Health State before making the instance eligible for rolling upgrades or instance repair operations. |
| HTTP/HTTPS protocol | Supported | Supported |
| TCP protocol | Supported | Limited Support Unknown state is unavailable on TCP protocol. See Rich Health States protocol table for Health State behaviors on TCP. |
1 The Unknown state is unavailable on TCP protocol.2 Only applicable for HTTP/HTTPS protocol. TCP protocol will follow the same process of identifying Unhealthy instances as in Binary Health States.
In general, you should use Binary Health States if:
- You're not interested in configuring custom logic to identify and flag an unhealthy instance
- You don't require an initializing grace period for newly created instances
You should use Rich Health States if:
- You send health signals through HTTP/HTTPS protocol and can submit health information through the probe response body
- You would like to use custom logic to identify and mark unhealthy instances
- You would like to set an initializing grace period for newly created instances, so that they settle into a steady Health State before making the instance eligible for rolling upgrade or instance repairs
Binary Health States
Binary Health State reporting contains two Health States, Healthy and Unhealthy. The following tables provide a brief description for how the Health States are configured.
HTTP/HTTPS Protocol
| Protocol | Health State | Description |
|---|---|---|
| http/https | Healthy | To send a Healthy signal, the application is expected to return a 200 response code. |
| http/https | Unhealthy | The instance will be marked as Unhealthy if a 200 response code isn't received from the application. |
TCP Protocol
| Protocol | Health State | Description |
|---|---|---|
| TCP | Healthy | To send a Healthy signal, a successful handshake must be made with the provided application endpoint. |
| TCP | Unhealthy | The instance will be marked as Unhealthy if a failed or incomplete handshake occurred with the provided application endpoint. |
Some scenarios that may result in an Unhealthy state include:
- When the application endpoint returns a non-200 status code
- When there's no application endpoint configured inside the virtual machine instances to provide application health status
- When the application endpoint is incorrectly configured
- When the application endpoint isn't reachable
Rich Health States
Rich Health States reporting contains four Health States, Initializing, Healthy, Unhealthy, and Unknown. The following tables provide a brief description for how each Health State is configured.
HTTP/HTTPS Protocol
| Protocol | Health State | Description |
|---|---|---|
| http/https | Healthy | To send a Healthy signal, the application is expected to return a probe response with: Probe Response Code: Status 2xx, Probe Response Body: {"ApplicationHealthState": "Healthy"} |
| http/https | Unhealthy | To send an Unhealthy signal, the application is expected to return a probe response with: Probe Response Code: Status 2xx, Probe Response Body: {"ApplicationHealthState": "Unhealthy"} |
| http/https | Initializing | The instance automatically enters an Initializing state at extension start time. For more information, see Initializing state. |
| http/https | Unknown | An Unknown state may occur in the following scenarios: when a non-2xx status code is returned by the application, when the probe request times out, when the application endpoint is unreachable or incorrectly configured, when a missing or invalid value is provided for ApplicationHealthState in the response body, or when the grace period expires. For more information, see Unknown state. |
TCP Protocol
| Protocol | Health State | Description |
|---|---|---|
| TCP | Healthy | To send a Healthy signal, a successful handshake must be made with the provided application endpoint. |
| TCP | Unhealthy | The instance will be marked as Unhealthy if a failed or incomplete handshake occurred with the provided application endpoint. |
| TCP | Initializing | The instance automatically enters an Initializing state at extension start time. For more information, see Initializing state. |
Initializing state
This state only applies to Rich Health States. The Initializing state only occurs once at extension start time and can be configured by the extension settings gracePeriod and numberOfProbes.
At extension startup, the application health will remain in the Initializing state until one of two scenarios occurs:
- The same Health State (Healthy or Unhealthy) is reported a consecutive number of times as configured through numberOfProbes
- The
gracePeriodexpires
If the same Health State (Healthy or Unhealthy) is reported consecutively, the application health will transition out of the Initializing state and into the reported Health State (Healthy or Unhealthy).
Example
If numberOfProbes = 3, that would mean:
- To transition from Initializing to Healthy state: Application health extension must receive three consecutive Healthy signals via HTTP/HTTPS or TCP protocol
- To transition from Initializing to Unhealthy state: Application health extension must receive three consecutive Unhealthy signals via HTTP/HTTPS or TCP protocol
If the gracePeriod expires before a consecutive health status is reported by the application, the instance health will be determined as follows:
- HTTP/HTTPS protocol: The application health will transition from Initializing to Unknown
- TCP protocol: The application health will transition from Initializing to Unhealthy
Unknown state
This state only applies to Rich Health States. The Unknown state is only reported for "http" or "https" probes and occurs in the following scenarios:
- When a non-2xx status code is returned by the application
- When the probe request times out
- When the application endpoint is unreachable or incorrectly configured
- When a missing or invalid value is provided for
ApplicationHealthStatein the response body - When the grace period expires
An instance in an Unknown state is treated similar to an Unhealthy instance. If enabled, instance repairs will be carried out on an Unknown instance while rolling upgrades will be paused until the instance falls back into a Healthy state.
The following table shows the health status interpretation for Rolling Upgrades and Instance Repairs:
| Health State | Rolling Upgrade interpretation | Instance Repairs trigger |
|---|---|---|
| Initializing | Wait for the state to be in Healthy, Unhealthy, or Unknown | No |
| Healthy | Healthy | No |
| Unhealthy | Unhealthy | Yes |
| Unknown | Unhealthy | Yes |
Extension schema for Binary Health States
The following JSON shows the schema for the Application Health extension. The extension requires at a minimum either a "tcp", "http" or "https" request with an associated port or request path respectively.
{ "extensionProfile" : { "extensions" : [ "name": "HealthExtension", "properties": { "publisher": "Microsoft.ManagedServices", "type": "<ApplicationHealthLinux or ApplicationHealthWindows>", "autoUpgradeMinorVersion": true, "typeHandlerVersion": "1.0", "settings": { "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>", "intervalInSeconds": 5, "numberOfProbes": 1 } } ] }} Property values
| Name | Value / Example | Data Type |
|---|---|---|
| apiVersion | 2018-10-01 | date |
| publisher | Microsoft.ManagedServices | string |
| type | ApplicationHealthLinux (Linux), ApplicationHealthWindows (Windows) | string |
| typeHandlerVersion | 1.0 | string |
Settings
| Name | Value / Example | Data Type |
|---|---|---|
| protocol | http or https or tcp | string |
| port | Optional when protocol is http or https, mandatory when protocol is tcp | int |
| requestPath | Mandatory when protocol is http or https, not allowed when protocol is tcp | string |
| intervalInSeconds | Optional, default is 5 seconds. This is the interval between each health probe. For example, if intervalInSeconds == 5, a probe will be sent to the local application endpoint once every 5 seconds. | int |
| numberOfProbes | Optional, default is 1. This is the number of consecutive probes required for the health status to change. For example, if numberOfProbles == 3, you will need 3 consecutive "Healthy" signals to change the health status from "Unhealthy" into "Healthy" state. The same requirement applies to change health status into "Unhealthy" state. | int |
Extension schema for Rich Health States
The following JSON shows the schema for the Rich Health States extension. The extension requires at a minimum either an "http" or "https" request with an associated port or request path respectively. TCP probes are also supported, but won't be able to set the ApplicationHealthState through the probe response body and won't have access to the Unknown state.
{ "extensionProfile" : { "extensions" : [ "name": "HealthExtension", "properties": { "publisher": "Microsoft.ManagedServices", "type": "<ApplicationHealthLinux or ApplicationHealthWindows>", "autoUpgradeMinorVersion": true, "typeHandlerVersion": "2.0", "settings": { "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>", "intervalInSeconds": 5, "numberOfProbes": 1, "gracePeriod": 600 } } ] }} Property values
| Name | Value / Example | Data Type |
|---|---|---|
| apiVersion | 2018-10-01 | date |
| publisher | Microsoft.ManagedServices | string |
| type | ApplicationHealthLinux (Linux), ApplicationHealthWindows (Windows) | string |
| typeHandlerVersion | 2.0 | string |
Settings
| Name | Value / Example | Data Type |
|---|---|---|
| protocol | http or https or tcp | string |
| port | Optional when protocol is http or https, mandatory when protocol is tcp | int |
| requestPath | Mandatory when protocol is http or https, not allowed when protocol is tcp | string |
| intervalInSeconds | Optional, default is 5 seconds. This is the interval between each health probe. For example, if intervalInSeconds == 5, a probe will be sent to the local application endpoint once every 5 seconds. | int |
| numberOfProbes | Optional, default is 1. This is the number of consecutive probes required for the health status to change. For example, if numberOfProbles == 3, you will need 3 consecutive "Healthy" signals to change the health status from "Unhealthy"/"Unknown" into "Healthy" state. The same requirement applies to change health status into "Unhealthy" or "Unknown" state. | int |
| gracePeriod | Optional, default = intervalInSeconds * numberOfProbes; maximum grace period is 7200 seconds | int |
Deploy the Application Health extension
There are multiple ways of deploying the Application Health extension to your scale sets as detailed in the following examples.
Binary Health States
The following example adds the Application Health extension (with name myHealthExtension) to the extensionProfile in the scale set model of a Windows-based scale set.
You can also use this example to change an existing extension from Rich Health State to Binary Health by making a PATCH call instead of a PUT.
PUT on `/subscriptions/subscription_id/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/myScaleSet/extensions/myHealthExtension?api-version=2018-10-01`{ "name": "myHealthExtension", "location": "<location>", "properties": { "publisher": "Microsoft.ManagedServices", "type": "ApplicationHealthWindows", "autoUpgradeMinorVersion": true, "typeHandlerVersion": "1.0", "settings": { "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>" } }}Use PATCH to edit an already deployed extension.
Upgrade the VMs to install the extension.
POST on `/subscriptions/<subscriptionId>/resourceGroups/<myResourceGroup>/providers/Microsoft.Compute/virtualMachineScaleSets/< myScaleSet >/manualupgrade?api-version=2022-08-01`{ "instanceIds": ["*"]}Use the Add-AzVmssExtension cmdlet to add the Application Health extension to the scale set model definition.
Update extension functionality is currently not available on PowerShell. To switch between Binary and Rich Health States, you can update the extension version using Azure CLI or REST API commands.
The following example adds the Application Health extension to the extensionProfile in the scale set model of a Windows-based scale set. The example uses the new Az PowerShell module.
# Define the scale set variables$vmScaleSetName = "myVMScaleSet"$vmScaleSetResourceGroup = "myVMScaleSetResourceGroup"# Define the Application Health extension properties$publicConfig = @{"protocol" = "http"; "port" = 80; "requestPath" = "/healthEndpoint"};$extensionName = "myHealthExtension"$extensionType = "ApplicationHealthWindows"$publisher = "Microsoft.ManagedServices"# Get the scale set object$vmScaleSet = Get-AzVmss ` -ResourceGroupName $vmScaleSetResourceGroup ` -VMScaleSetName $vmScaleSetName# Add the Application Health extension to the scale set modelAdd-AzVmssExtension -VirtualMachineScaleSet $vmScaleSet ` -Name $extensionName ` -Publisher $publisher ` -Setting $publicConfig ` -Type $extensionType ` -TypeHandlerVersion "1.0" ` -AutoUpgradeMinorVersion $True# Update the scale setUpdate-AzVmss -ResourceGroupName $vmScaleSetResourceGroup ` -Name $vmScaleSetName ` -VirtualMachineScaleSet $vmScaleSet # Upgrade instances to install the extensionUpdate-AzVmssInstance -ResourceGroupName $vmScaleSetResourceGroup ` -VMScaleSetName $vmScaleSetName ` -InstanceId '*'Use az vmss extension set to add the Application Health extension to the scale set model definition.
The following example adds the Application Health extension to the scale set model of a Linux-based scale set.
You can also use this example to change an existing extension from Rich Health States to Binary Health.
az vmss extension set --name ApplicationHealthLinux --publisher Microsoft.ManagedServices --version 1.0 --resource-group <myVMScaleSetResourceGroup> --vmss-name <myVMScaleSet> --settings ./extension.jsonThe extension.json file content.
{ "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>"}Upgrade the VMs to install the extension.
az vmss update-instances --resource-group <myVMScaleSetResourceGroup> --name <myVMScaleSet> --instance-ids "*"Rich Health States
The following example adds the Application Health - Rich States extension (with name myHealthExtension) to the extensionProfile in the scale set model of a Windows-based scale set.
You can also use this example to upgrade an existing extension from Binary to Rich Health States by making a PATCH call instead of a PUT.
PUT on `/subscriptions/subscription_id/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/myScaleSet/extensions/myHealthExtension?api-version=2018-10-01`{ "name": "myHealthExtension", "location": "<location>", "properties": { "publisher": "Microsoft.ManagedServices", "type": "ApplicationHealthWindows", "autoUpgradeMinorVersion": true, "typeHandlerVersion": "2.0", "settings": { "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>", "intervalInSeconds": <intervalInSeconds>, "numberOfProbes": <numberOfProbes>, "gracePeriod": <gracePeriod> } }}Use PATCH to edit an already deployed extension.
Upgrade the VMs to install the extension.
POST on `/subscriptions/<subscriptionId>/resourceGroups/<myResourceGroup>/providers/Microsoft.Compute/virtualMachineScaleSets/< myScaleSet >/manualupgrade?api-version=2022-08-01`{ "instanceIds": ["*"]}Use the Add-AzVmssExtension cmdlet to add the Application Health extension to the scale set model definition.
Update extension functionality is currently not available on PowerShell. To switch between Binary and Rich Health States, you can update the extension version using Azure CLI or REST API commands.
The following example adds the Application Health - Rich States extension to the extensionProfile in the scale set model of a Windows-based scale set. The example uses the new Az PowerShell module.
# Define the scale set variables$vmScaleSetName = "myVMScaleSet"$vmScaleSetResourceGroup = "myVMScaleSetResourceGroup"# Define the Application Health extension properties$publicConfig = @{"protocol" = "http"; "port" = 80; "requestPath" = "/healthEndpoint"; "gracePeriod" = 600};$extensionName = "myHealthExtension"$extensionType = "ApplicationHealthWindows"$publisher = "Microsoft.ManagedServices"# Get the scale set object$vmScaleSet = Get-AzVmss ` -ResourceGroupName $vmScaleSetResourceGroup ` -VMScaleSetName $vmScaleSetName# Add the Application Health extension to the scale set modelAdd-AzVmssExtension -VirtualMachineScaleSet $vmScaleSet ` -Name $extensionName ` -Publisher $publisher ` -Setting $publicConfig ` -Type $extensionType ` -TypeHandlerVersion "2.0" ` -AutoUpgradeMinorVersion $True# Update the scale setUpdate-AzVmss -ResourceGroupName $vmScaleSetResourceGroup ` -Name $vmScaleSetName ` -VirtualMachineScaleSet $vmScaleSet # Upgrade instances to install the extensionUpdate-AzVmssInstance -ResourceGroupName $vmScaleSetResourceGroup ` -VMScaleSetName $vmScaleSetName ` -InstanceId '*'Use az vmss extension set to add the Application Health extension to the scale set model definition.
The following example adds the Application Health - Rich States extension to the scale set model of a Linux-based scale set.
You can also use this example to upgrade an existing extension from Binary to Rich Health States.
az vmss extension set --name ApplicationHealthLinux --publisher Microsoft.ManagedServices --version 2.0 --resource-group <myVMScaleSetResourceGroup> --vmss-name <myVMScaleSet> --settings ./extension.jsonThe extension.json file content.
{ "protocol": "<protocol>", "port": <port>, "requestPath": "</requestPath>", "gracePeriod": <healthExtensionGracePeriod>}Upgrade the VMs to install the extension.
az vmss update-instances --resource-group <myVMScaleSetResourceGroup> --name <myVMScaleSet> --instance-ids "*"Troubleshoot
View VMHealth - single instance
Get-AzVmssVM -InstanceView ` -ResourceGroupName <rgName>` -VMScaleSetName <vmssName> ` -InstanceId <instanceId> View VMHealth batch call
This is only available for Virtual Machine Scale Sets with Uniform orchestration.
GET on `/subscriptions/<subscriptionID>/resourceGroups/<resourceGroupName>/providers/Microsoft.Compute/virtualMachineScaleSets/<vmssName>/virtualMachines/?api-version=2022-03-01&$expand=instanceview`Health State isn't showing up
If Health State isn't showing up in Azure portal or via GET call, check to ensure that the VM is upgraded to the latest model. If the VM isn't on the latest model, upgrade the VM and the health status will come up.
Extension execution output log
Extension execution output is logged to files found in the following directories:
C:WindowsAzureLogsPluginsMicrosoft.ManagedServices.ApplicationHealthWindows<version>/var/lib/waagent/Microsoft.ManagedServices.ApplicationHealthLinux-<extension_version>/status/var/log/azure/applicationhealth-extensionThe logs also periodically capture the application health status.
Next steps
Learn how to deploy your application on Virtual Machine Scale Sets.
