Deleting a Job also deletes all Tasks that are part of that Job, and all Job statistics. This also overrides the retention period for Task data; that is, if the Job contains Tasks which are still retained on Compute Nodes, the Batch service deletes those Tasks’ working directories and all their contents. When a Delete Job request is received, the Batch service sets the Job to the deleting state. All update operations on a Job that is in deleting state will fail with status code 409 (Conflict), with additional information indicating that the Job is being deleted.

We can use below PowerShell command to delete one single job using job id:

Remove-AzBatchJob -Id “Job-000001” -BatchContext $Context

But if you have a large number of jobs and wants to delete them simultaneously, then you can refer below PowerShell command for the same:

# Replace with your Azure Batch account name, resource group, and subscription ID
$accountName = “yourBatchAccountName”
$resourceGroupName = “yourResourceGroupName”

# Authenticate to Azure
Connect-AzAccount

# Get the Batch account context
$batchContext = Get-AzBatchAccount -Name $accountName -ResourceGroupName $resourceGroupName

# Get all batch jobs with creation time before May 2024
# Replace the creation time date accordingly

$jobsForDelete = Get-AzBatchJob -BatchContext $batchContext | Where-Object {$_.CreationTime -lt “2024-05-01”}

# List the jobs
Write-Host “Jobs to be deleted:”
foreach ($job in $jobsForDelete) {
Write-Host $job.Id
# Write-Host “Deleting jobs…”
Remove-AzBatchJob -Id $job.Id -BatchContext $batchContext -Force
}

The above script will delete all the jobs created before the creation date. You can accordingly modify the parameters as per your requirement.

​Microsoft Tech Community – Latest Blogs –Read More 

Parallel programming in C# uses a variation of Managed Threading, that relies on PLINQ, Expression Trees, The Barrier Class, Thread Class, BackgroundWorker Class, SpinWait Struct, SpinLock Struct, and Thread-Tracking Mode for SpinLock. The reason is that it’s faster to use the environment to determine how many cores / threads are available, as to not starve the device of resources, which at that point, you have to use the BackgroundWorker Class to manage each task you’ve created. Often in this scenario, you can end up with a deadlock condition, because you have more than one task trying to access a shared resource. It’s much easier and faster to split up each task, ONLY using byte arrays, assigning each task individual byte arrays to sort / parse, encrypted or not, with the Stream class, or a sub variation of that Class, and then when each task finishes, they all finish at different times, but the shared resource is divided up into portions, so that they will only be able to fill one area of that array. The reason why Barrier is used in this situation, is it forces each one to wait until all the tasks are finished, or until they all ARRIVE at the same place, which solves one timing issue, yet it might create another where there’s a bit of a timing mismatch if your estimates are wrong, you overshoot or undershoot I mean. At the very end, you can use a separate process to just COPY from each individual array, without a deadlock scenario occurring. The only issue, is you have to estimate how many threads are available ahead of time, and you can’t use every single thread, yet you’re going to have to divide a single resource between all those threads. Beforehand, you have to verify if it’s a waste of time to use more than one thread. The reason why I say this, is that a lot of people use reference types, not knowing they are immutable, and they take a huge / massive performance hit because of this. Often you have to convert strings into byte arrays, or use a pre-initialized character array at the start of the program, which contains the Unicode values that you want to recast individually as strings, and then use a byte array as an INDEX or a placeholder, of a Unicode character array. If you’re not encrypting the byte arrays, or using them for text parsing, which byte arrays tend to be best in high throughput scenarios, than integer arrays will suffice. The index can be scrambled based on how you want to represent that one string, though it’s smarter to only cast a new reference type when you want to display text on the screen. If you spend too much time manually parsing using built-in libraries, it’s REALLY SLOW. A byte array is better to use than an integer array in this sort of situation. You might have to create separate indexes with a byte array representing a set of binary flags, to determine whether each one is a letter, number, symbol, etc, or how you want to classify each one based on the code chart that you’re using. You would be better off in that situation to just use right shift / left shift / XOR, etc, to set the flags. Then you have something which is also very fast, and almost equivalent to a Barrel Shifter, given C# does not allow you to use pointers, as it’s managed code / a managed environment. All the Boolean Logical Operators with Compound Assignment rely on pre-initialized Cast Expressions of Integer Literals, Bitwise and Shift Operators, combined with Lambda Expressions, and Operator Overloading. The purpose of the Shift Operators is to mask / pad the bits of one byte value with zeroes, so that your Cast Expression Of An Integer Literal, which serves at the mask, always gives you a fixed / deterministic result, when used in conjunction with Boolean Logical Operators, especially if the value is smaller than 8-bits / a single byte, or you’re dealing with a larger array has to represent a flag “register” with a size of ( 2 ^ 8 ) 256 bits, which is basically a Double-Word:

“Microsoft Learn – Boolean logical operators – AND, OR, NOT, XOR – Compound assignment” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/boolean-logical-operators#compound-assignment”
“Microsoft Learn – Bitwise and shift operators (C# reference)” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators”
“Microsoft Learn – Operator overloading – predefined unary, arithmetic, equality and comparison operators” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading”
“Microsoft Learn – Lambda expressions and anonymous functions” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions”
“Microsoft Learn – Integral numeric types (C# reference) – Integer literals” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types#integer-literals”
“Microsoft Learn – Type-testing operators and cast expressions – is, as, typeof and casts – Cast expression” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/type-testing-and-cast#cast-expression”

“Microsoft Learn – Deserialization risks in use of BinaryFormatter and related types” -> “https://learn.microsoft.com/en-us/dotnet/standard/serialization/binaryformatter-security-guide”
“Microsoft Learn – BinaryReader Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.binaryreader?view=netframework-4.0”
“Microsoft Learn – Stream Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.stream?view=netframework-4.0”
“Microsoft Learn – StreamWriter Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.streamwriter?view=netframework-4.0”
“Microsoft Learn – StreamReader Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.streamreader?view=netframework-4.0”
“Microsoft Learn – File and Stream I/O” -> “https://learn.microsoft.com/en-us/dotnet/standard/io/”
“Microsoft Learn – Pipe Functions” -> “https://learn.microsoft.com/en-us/windows/win32/ipc/pipe-functions”
“Microsoft Learn – System.IO.Pipes Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.pipes?view=netframework-4.0”
“Microsoft Learn – Custom Partitioners for PLINQ and TPL” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/custom-partitioners-for-plinq-and-tpl”
“Microsoft Learn – Expression Trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/”
“Microsoft Learn – Build expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-building”
“Microsoft Learn – Translate expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-translating”
“Microsoft Learn – Execute expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-execution”
“Microsoft Learn – System.Windows.Threading Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading?view=netframework-4.0”
“Microsoft Learn – System.Threading Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading?view=netframework-4.0”
“Microsoft Learn – System.Threading.Channels Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.channels?view=netcore-3.0”
“Microsoft Learn – System.Threading.Tasks Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks?view=netframework-4.0”
“Microsoft Learn – Timer Class (System.Timers)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.timers?view=netframework-4.0”
“Microsoft Learn – Timer Class (System.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.timer?view=netframework-4.0”
“Microsoft Learn – DispatcherTimer Class (System.Windows.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading.dispatchertimer?view=netframework-4.0”
“Microsoft Learn – Dispatcher Class (System.Windows.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading.dispatcher?view=netframework-4.0”
“Microsoft Learn – Threads and threading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/threads-and-threading”
“Microsoft Learn – Using threads and threading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/using-threads-and-threading”
“Microsoft Learn – Introduction to PLINQ” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/introduction-to-plinq”
“Microsoft Learn – Task Parallel Library (TPL)” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-parallel-library-tpl”
“Microsoft Learn – Lambda Expressions in PLINQ and TPL” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/lambda-expressions-in-plinq-and-tpl”
“Microsoft Learn – Multithreading in Windows Forms Controls” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/multithreading-in-windows-forms-controls”
“Microsoft Learn – Managed threading best practices” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices”
“Microsoft Learn – Parallel programming in .NET: A guide to the documentation” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/”
“Microsoft Learn – Thread Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.thread”
“Microsoft Learn – BackgroundWorker Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.backgroundworker”
“Microsoft Learn – Synchronizing data for multithreading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/synchronizing-data-for-multithreading”
“Microsoft Learn – Overview of synchronization primitives” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/overview-of-synchronization-primitives”
“Microsoft Learn – Environment.ProcessorCount Property” -> “https://learn.microsoft.com/en-us/dotnet/api/system.environment.processorcount”
“Microsoft Learn – Managed threading best practices – Number of Processors” -> “https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-1.1/1c9txz50(v=vs.71)#number-of-processors”
“Microsoft Learn – lock statement – ensure exclusive access to a shared resource” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/lock”
“Microsoft Learn – Reliability Best Practices” -> “https://learn.microsoft.com/en-us/dotnet/framework/performance/reliability-best-practices”
“Microsoft Learn – BackgroundWorker Component Overview” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/backgroundworker-component-overview”
“Microsoft Learn – How to: Run an Operation in the Background” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/how-to-run-an-operation-in-the-background”
“Microsoft Learn – Thread-safe collections” -> “https://learn.microsoft.com/en-us/dotnet/standard/collections/thread-safe/”
“Microsoft Learn – Threading objects and features” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/threading-objects-and-features”
“Microsoft Learn – Barrier” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/barrier”
“Microsoft Learn – Barrier Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.barrier?view=netframework-4.0”
“Microsoft Learn – SpinWait” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/spinwait”
“Microsoft Learn – SpinWait Struct” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.spinwait?view=netframework-4.0”
“Microsoft Learn – SpinLock” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/spinlock”
“Microsoft Learn – SpinLock Struct” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.spinlock?view=netframework-4.0”
“Microsoft Learn – How to: use SpinLock for low-level synchronization” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/how-to-use-spinlock-for-low-level-synchronization”
“Microsoft Learn – How to: Enable Thread-Tracking Mode in SpinLock” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/how-to-enable-thread-tracking-mode-in-spinlock”
“Microsoft Learn – Chaining tasks using continuation tasks” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/chaining-tasks-by-using-continuation-tasks”
“Microsoft Learn – Interlocked Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.interlocked?view=netframework-4.0”
“Microsoft Learn – TaskFactory Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskfactory?view=netframework-4.0”

​Parallel programming in C# uses a variation of Managed Threading, that relies on PLINQ, Expression Trees, The Barrier Class, Thread Class, BackgroundWorker Class, SpinWait Struct, SpinLock Struct, and Thread-Tracking Mode for SpinLock. The reason is that it’s faster to use the environment to determine how many cores / threads are available, as to not starve the device of resources, which at that point, you have to use the BackgroundWorker Class to manage each task you’ve created. Often in this scenario, you can end up with a deadlock condition, because you have more than one task trying to access a shared resource. It’s much easier and faster to split up each task, ONLY using byte arrays, assigning each task individual byte arrays to sort / parse, encrypted or not, with the Stream class, or a sub variation of that Class, and then when each task finishes, they all finish at different times, but the shared resource is divided up into portions, so that they will only be able to fill one area of that array. The reason why Barrier is used in this situation, is it forces each one to wait until all the tasks are finished, or until they all ARRIVE at the same place, which solves one timing issue, yet it might create another where there’s a bit of a timing mismatch if your estimates are wrong, you overshoot or undershoot I mean. At the very end, you can use a separate process to just COPY from each individual array, without a deadlock scenario occurring. The only issue, is you have to estimate how many threads are available ahead of time, and you can’t use every single thread, yet you’re going to have to divide a single resource between all those threads. Beforehand, you have to verify if it’s a waste of time to use more than one thread. The reason why I say this, is that a lot of people use reference types, not knowing they are immutable, and they take a huge / massive performance hit because of this. Often you have to convert strings into byte arrays, or use a pre-initialized character array at the start of the program, which contains the Unicode values that you want to recast individually as strings, and then use a byte array as an INDEX or a placeholder, of a Unicode character array. If you’re not encrypting the byte arrays, or using them for text parsing, which byte arrays tend to be best in high throughput scenarios, than integer arrays will suffice. The index can be scrambled based on how you want to represent that one string, though it’s smarter to only cast a new reference type when you want to display text on the screen. If you spend too much time manually parsing using built-in libraries, it’s REALLY SLOW. A byte array is better to use than an integer array in this sort of situation. You might have to create separate indexes with a byte array representing a set of binary flags, to determine whether each one is a letter, number, symbol, etc, or how you want to classify each one based on the code chart that you’re using. You would be better off in that situation to just use right shift / left shift / XOR, etc, to set the flags. Then you have something which is also very fast, and almost equivalent to a Barrel Shifter, given C# does not allow you to use pointers, as it’s managed code / a managed environment. All the Boolean Logical Operators with Compound Assignment rely on pre-initialized Cast Expressions of Integer Literals, Bitwise and Shift Operators, combined with Lambda Expressions, and Operator Overloading. The purpose of the Shift Operators is to mask / pad the bits of one byte value with zeroes, so that your Cast Expression Of An Integer Literal, which serves at the mask, always gives you a fixed / deterministic result, when used in conjunction with Boolean Logical Operators, especially if the value is smaller than 8-bits / a single byte, or you’re dealing with a larger array has to represent a flag “register” with a size of ( 2 ^ 8 ) 256 bits, which is basically a Double-Word:”Microsoft Learn – Boolean logical operators – AND, OR, NOT, XOR – Compound assignment” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/boolean-logical-operators#compound-assignment”
“Microsoft Learn – Bitwise and shift operators (C# reference)” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/bitwise-and-shift-operators”
“Microsoft Learn – Operator overloading – predefined unary, arithmetic, equality and comparison operators” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading”
“Microsoft Learn – Lambda expressions and anonymous functions” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions”
“Microsoft Learn – Integral numeric types (C# reference) – Integer literals” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/integral-numeric-types#integer-literals”
“Microsoft Learn – Type-testing operators and cast expressions – is, as, typeof and casts – Cast expression” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/type-testing-and-cast#cast-expression”

“Microsoft Learn – Deserialization risks in use of BinaryFormatter and related types” -> “https://learn.microsoft.com/en-us/dotnet/standard/serialization/binaryformatter-security-guide”
“Microsoft Learn – BinaryReader Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.binaryreader?view=netframework-4.0”
“Microsoft Learn – Stream Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.stream?view=netframework-4.0”
“Microsoft Learn – StreamWriter Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.streamwriter?view=netframework-4.0”
“Microsoft Learn – StreamReader Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.streamreader?view=netframework-4.0”
“Microsoft Learn – File and Stream I/O” -> “https://learn.microsoft.com/en-us/dotnet/standard/io/”
“Microsoft Learn – Pipe Functions” -> “https://learn.microsoft.com/en-us/windows/win32/ipc/pipe-functions”
“Microsoft Learn – System.IO.Pipes Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.io.pipes?view=netframework-4.0”
“Microsoft Learn – Custom Partitioners for PLINQ and TPL” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/custom-partitioners-for-plinq-and-tpl”
“Microsoft Learn – Expression Trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/”
“Microsoft Learn – Build expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-building”
“Microsoft Learn – Translate expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-translating”
“Microsoft Learn – Execute expression trees” -> “https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-execution”
“Microsoft Learn – System.Windows.Threading Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading?view=netframework-4.0”
“Microsoft Learn – System.Threading Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading?view=netframework-4.0”
“Microsoft Learn – System.Threading.Channels Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.channels?view=netcore-3.0”
“Microsoft Learn – System.Threading.Tasks Namespace” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks?view=netframework-4.0”
“Microsoft Learn – Timer Class (System.Timers)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.timers?view=netframework-4.0”
“Microsoft Learn – Timer Class (System.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.timer?view=netframework-4.0”
“Microsoft Learn – DispatcherTimer Class (System.Windows.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading.dispatchertimer?view=netframework-4.0”
“Microsoft Learn – Dispatcher Class (System.Windows.Threading)” -> “https://learn.microsoft.com/en-us/dotnet/api/system.windows.threading.dispatcher?view=netframework-4.0”
“Microsoft Learn – Threads and threading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/threads-and-threading”
“Microsoft Learn – Using threads and threading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/using-threads-and-threading”
“Microsoft Learn – Introduction to PLINQ” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/introduction-to-plinq”
“Microsoft Learn – Task Parallel Library (TPL)” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-parallel-library-tpl”
“Microsoft Learn – Lambda Expressions in PLINQ and TPL” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/lambda-expressions-in-plinq-and-tpl”
“Microsoft Learn – Multithreading in Windows Forms Controls” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/multithreading-in-windows-forms-controls”
“Microsoft Learn – Managed threading best practices” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices”
“Microsoft Learn – Parallel programming in .NET: A guide to the documentation” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/”
“Microsoft Learn – Thread Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.thread”
“Microsoft Learn – BackgroundWorker Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.componentmodel.backgroundworker”
“Microsoft Learn – Synchronizing data for multithreading” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/synchronizing-data-for-multithreading”
“Microsoft Learn – Overview of synchronization primitives” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/overview-of-synchronization-primitives”
“Microsoft Learn – Environment.ProcessorCount Property” -> “https://learn.microsoft.com/en-us/dotnet/api/system.environment.processorcount”
“Microsoft Learn – Managed threading best practices – Number of Processors” -> “https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-1.1/1c9txz50(v=vs.71)#number-of-processors”
“Microsoft Learn – lock statement – ensure exclusive access to a shared resource” -> “https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/lock”
“Microsoft Learn – Reliability Best Practices” -> “https://learn.microsoft.com/en-us/dotnet/framework/performance/reliability-best-practices”
“Microsoft Learn – BackgroundWorker Component Overview” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/backgroundworker-component-overview”
“Microsoft Learn – How to: Run an Operation in the Background” -> “https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/how-to-run-an-operation-in-the-background”
“Microsoft Learn – Thread-safe collections” -> “https://learn.microsoft.com/en-us/dotnet/standard/collections/thread-safe/”
“Microsoft Learn – Threading objects and features” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/threading-objects-and-features”
“Microsoft Learn – Barrier” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/barrier”
“Microsoft Learn – Barrier Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.barrier?view=netframework-4.0”
“Microsoft Learn – SpinWait” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/spinwait”
“Microsoft Learn – SpinWait Struct” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.spinwait?view=netframework-4.0”
“Microsoft Learn – SpinLock” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/spinlock”
“Microsoft Learn – SpinLock Struct” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.spinlock?view=netframework-4.0”
“Microsoft Learn – How to: use SpinLock for low-level synchronization” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/how-to-use-spinlock-for-low-level-synchronization”
“Microsoft Learn – How to: Enable Thread-Tracking Mode in SpinLock” -> “https://learn.microsoft.com/en-us/dotnet/standard/threading/how-to-enable-thread-tracking-mode-in-spinlock”
“Microsoft Learn – Chaining tasks using continuation tasks” -> “https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/chaining-tasks-by-using-continuation-tasks”
“Microsoft Learn – Interlocked Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.interlocked?view=netframework-4.0”
“Microsoft Learn – TaskFactory Class” -> “https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskfactory?view=netframework-4.0”  Read More

​

What is Speech Service

The Speech service provides speech to text and text to speech capabilities with a Speech resource

It is one of the types of Cognitive Accounts i.e.- type”: “Microsoft.CognitiveServices/accounts and “kind”: “SpeechServices”,

What is restrictOutboundNetworkAccess property and why do we use it?

restrictOutboundNetworkAccess property is used in speech services to enable data loss prevention. When this property is enabled, the Speech service will connect only to the allowed endpoints as specified in the list of FQDN allowed endpoints. For e.g.-> if you need to transcribe data which comes from a blob, the FQDN of your storage account should be in this list. If this property  is not set as true, Speech service won’t be able to access your storage account.

Reference document which explains about this property- https://learn.microsoft.com/en-us/azure/ai-services/cognitive-services-data-loss-prevention?tabs=azure-cli

How to enable/Disable restrictOutboundNetworkAccess for Speech Services?

You cannot deploy your speech service manually from Azure Portal with “restrictOutboundNetworkAccess” property as true or false.

We can deploy Speech Services using ARM/PowerShell/terraform with property restrictOutboundNetworkAccess set as true or false

Using CLI/powershell, reference:- Data loss prevention – Azure AI services | Microsoft Learn

Using ARM template, reference: Microsoft.CognitiveServices/accounts – Bicep, ARM template & Terraform AzAPI reference | Microsoft Learn

Sample Code for Deploying Speech Service with restrictOutboundNetworkAccess as true and list of allowed FQDN using custom template deployment from Azure Portal

Please note that with restrictOutboundNetworkAccess property, we are also using allowedFqdnList which will include list of URL’s that can be accessible by Speech Services

{
    “$schema”: “https://schema.management.azure.com/schemas/2019-04-01 deploymentTemplate.json#”,
    “contentVersion”: “1.0.0.0”,
    “parameters”: {
        “cognitiveServiceName”: {
            “type”: “String”,
            “metadata”: {
                “description”: “Name of the Cognitive Service account”
            }
        },
        “location”: {
            “defaultValue”: “[resourceGroup().location]”,
            “type”: “String”,
            “metadata”: {
                “description”: “Location for the Cognitive Service account”
            }
        },
        “sku”: {
            “defaultValue”: “F0”,
            “allowedValues”: [
                “F0”,
                “S0”
            ],
            “type”: “String”,
            “metadata”: {
                “description”: “The pricing tier of the Cognitive Service account”
            }
        }
    },
    “resources”: [
        {
            “type”: “Microsoft.CognitiveServices/accounts”,
            “apiVersion”: “2022-12-01”,
            “name”: “[parameters(‘cognitiveServiceName’)]”,
            “location”: “[parameters(‘location’)]”,
            “sku”: {
                “name”: “[parameters(‘sku’)]”
            },
            “kind”: “SpeechServices”,
            “properties”: {
                “restrictOutboundNetworkAccess”: true,
                “disableLocalAuth”: true,
                “allowedFqdnList”: [
                    “microsoft.com”
                ]
            }
        }
    ]
}

Above code will deploy your speech service with restrictOutboundNetworkAccess as “true”

How to check whether restrictOutboundNetworkAccess is enabled/disabled for Speech Services

We can go to JSON view of Deployed Resource and check if the property is set as “true” or “false”

Reference document for Use Cases of testing can be found here – Use Cases for Testing Restrictoutboundnetworkaccess for Speech Service – Microsoft Community Hub

​Microsoft Tech Community – Latest Blogs –Read More 

We’re upgrading the AD domain from 2008R2 to 2022.

we deployed the new 2022 DC and also successfully moved the FSMO roles.

however some old 2003 servers started having issue authenticating clients, as for example connecting to file shares, with kdc errors.

“The encryption type requested is not supported by the KDC”

how can we fix it ?

is there a group policy we can apply to the 2022 DC to enable the old 2003 servers to authenticate clients ?

thanks

​We’re upgrading the AD domain from 2008R2 to 2022.we deployed the new 2022 DC and also successfully moved the FSMO roles.however some old 2003 servers started having issue authenticating clients, as for example connecting to file shares, with kdc errors.“The encryption type requested is not supported by the KDC” how can we fix it ?is there a group policy we can apply to the 2022 DC to enable the old 2003 servers to authenticate clients ?thanks   Read More

​

While importing the data in the SQL Server, I am getting this error.

I am not able to solve the error after trying so much in the internet and youtube also.
Can anyone help in solving me this error.

​While importing the data in the SQL Server, I am getting this error.  I am not able to solve the error after trying so much in the internet and youtube also.Can anyone help in solving me this error.  Read More

​

Our mission overall has been to democratize access to supercomputing. We’ve always believed that people could do great things with access to high performance compute. So, while hosting the AI revolution was never the plan, its very existence has validated our strategy of sitting at the intersection of two movements in IT, cloud computing and Beowulf clusters, to tackle the biggest obstacles in access to supercomputing.

Cloud Computing

When it comes to resource allocation, the cloud is about adapting to customer demand, on demand, as efficiently as possible.

It needs to satisfy startup who needs to start small but also scale up seamlessly as their business takes off or a retailer who needs more capacity for the holiday rush but doesn’t want to pay for it year-round. Cloud providers manage these huge changes, across time as well as across customers, with virtualization.

Instead of installing new hardware for each deployment, the cloud runs hypervisor software that can take powerful servers and carve them up into smaller virtual machines on the fly. That can let it create these virtual machines, move them between servers, and destroy them in seconds.

It’s through these operations that the cloud can offer virtually unlimited flexibility to customers as a differentiating factor.

Beowulf Clusters

Since 1994, when researchers at NASA built their Beowulf supercomputer by connecting a bunch of PCs together over Ethernet, clustering together commodity hardware has increasingly become the way supercomputers are built.

The main driver for this shift is economies of scale. Custom designs tend to make more efficient use of each processor, but if I can buy raspberry pi’s at half as much per FLOPS, then even reaching 60% efficiency makes it a win.

A system’s efficiency in this context is the ratio of how quickly it can do useful work on a real job compared to just adding up the FLOPS across all its parts. Beowulf clusters tend to perform worse on this metric, and that’s mainly due to custom silicon being more optimized for targeted workloads, as well as network bottlenecks often leaving Beowulf nodes stuck waiting for data.

As Beowulf-style clusters gained traction, specialized accelerators and networking technologies popped up to boost their efficiency. Accelerators like GPUs targeted specific types of computation, while new network protocols like InfiniBand/RDMA optimized for the static, closed nature of these “backend” networks and the communication patterns they carry.

Azure HPC

Besides bringing costs down in general, Beowulf clusters are modular enough for us to run back the same virtualization playbook from cloud computing. Instead of using a hypervisor to carve out sets of cores, we use network partitions to carve out sets of nodes.

To a customer, this means creating a group of “RDMA-enabled” VMs together with a specific setting, which tells us to put these VMs on the same network partition.

And that’s what lets us offer supercomputing in the cloud, which brings with it interesting opportunities for customers.

On their own cluster, if they want a job done in half the time, they might pay twice as much for a bigger cluster. In the cloud, that cost would stay flat because they’re only renting the bigger cluster for half as long. In a sense, it’s holiday rush bursting taken to the extreme, and it’s made Azure HPC popular in industries where R&D relies heavily on supercomputing and time to market is everything.

In 2022, that could have been the end of the story, but with the rise of AI, we now serve an industry that uses supercomputing not only in R&D (training) but also in production (inference), making us an attractive platform for this generation of startups.

And that, in a nutshell, how Azure HPC works, serving customers small and large the latest server and accelerator technologies, tied together with a high-performance backend interconnect and offered through the Azure Cloud.

I felt compelled to write this because within Azure, we’re often referred to as “InfiniBand Team” or “Azure GPU” or “AI Platform”, and while I appreciate that those three are and likely will continue to be a wildly successful combination of network, accelerator, and use-case, I like to think you could swap any of them out, and we’d still be Azure HPC.

​Microsoft Tech Community – Latest Blogs –Read More 

Hi, folks.

I leverage the following three settings under User/Administrative Templates/Windows Components/File Explorer to effectively disable the Recycle Bin and force prompting for deletions on all Windows Server hosts, yet on Windows Server 2022, they are having no effect.

The description for each setting contains no hints as to whether they’ve been deliberately omitted from Windows Server 2022 (most likely) or this is just some kind of bug/accidental omission.

I ran a cross-check using the local group policy editor on a Server 2022 host as I haven’t specifically updated the domain templates to Server 2022, but it’s the same outcome.

Does anyone have any insight as to whether these settings have been dropped as of Server 2022/Windows 11?

Cheers,

Lain

​Hi, folks. I leverage the following three settings under User/Administrative Templates/Windows Components/File Explorer to effectively disable the Recycle Bin and force prompting for deletions on all Windows Server hosts, yet on Windows Server 2022, they are having no effect.  The description for each setting contains no hints as to whether they’ve been deliberately omitted from Windows Server 2022 (most likely) or this is just some kind of bug/accidental omission. I ran a cross-check using the local group policy editor on a Server 2022 host as I haven’t specifically updated the domain templates to Server 2022, but it’s the same outcome. Does anyone have any insight as to whether these settings have been dropped as of Server 2022/Windows 11? Cheers,Lain  Read More

​

At my organization I am working on a SharePoint list having 3 lookup columns for another list.

And to add new items in bulk I used to, open a view in quick edit mode, copy paste data from excel and worked perfectly fine.

Since a few weeks, after I guess some recent SharePoint update, when I do bulk upload, the lookup gets populated with some garbage values as hyperlink.

Initially I thought it displaying the item id from the lookup list. But it’s not, it’s just a long string of numbers.

Alternatively, it works perfectly fine when I open and edit the list Classic SharePoint.

Can anyone help me with this? Or is it a bug that Microsoft needs to fix?

Thanks,

Harsh

​At my organization I am working on a SharePoint list having 3 lookup columns for another list.And to add new items in bulk I used to, open a view in quick edit mode, copy paste data from excel and worked perfectly fine. Since a few weeks, after I guess some recent SharePoint update, when I do bulk upload, the lookup gets populated with some garbage values as hyperlink. Initially I thought it displaying the item id from the lookup list. But it’s not, it’s just a long string of numbers. Alternatively, it works perfectly fine when I open and edit the list Classic SharePoint. Can anyone help me with this? Or is it a bug that Microsoft needs to fix? Thanks,Harsh  Read More

​

Hi All

I have special requirement where the offline task sequence media needs to be used to image the laptops, but in following manner:

– TS media with autorun is burnt to a USB as bootable

– User being logged in to the machine, if he wants to reimage the machine, he just plugin the USB and run launchmedia.bat or any other custom script.

Is there any possibility to achieve the above requirement.

Thank you

Regards

Ramesh

​Hi All I have special requirement where the offline task sequence media needs to be used to image the laptops, but in following manner:- TS media with autorun is burnt to a USB as bootable- User being logged in to the machine, if he wants to reimage the machine, he just plugin the USB and run launchmedia.bat or any other custom script.Is there any possibility to achieve the above requirement. Thank youRegardsRamesh  Read More

​

Every time I boot my Windows 10 Pro desktop computer, I get a OneDrive pop-up message that says “OneDrive is not signed in” and it cannot sync my OneDrive folders until I sign in.

This started happening very recently and I’d never seen this problem until it started a couple of weeks ago.

I have signed in to OneDrive after logging on to my computer, but the pop-up appears the next time the computer is booted.

I have uninstalled and reinstalled OneDrive, but the problem remains.

I have disconnected the computer from OneDrive and reconnected it to OneDrive, but the problem remains.

I have checked all my OneDrive settings and cannot find anything that would cause this problem.

I have a Windows 11 laptop which is signed into the same Microsoft account and it does not have this problem.

I’ve run out of ideas! Can anyone help?

Thanks.

​Every time I boot my Windows 10 Pro desktop computer, I get a OneDrive pop-up message that says “OneDrive is not signed in” and it cannot sync my OneDrive folders until I sign in. This started happening very recently and I’d never seen this problem until it started a couple of weeks ago. I have signed in to OneDrive after logging on to my computer, but the pop-up appears the next time the computer is booted. I have uninstalled and reinstalled OneDrive, but the problem remains. I have disconnected the computer from OneDrive and reconnected it to OneDrive, but the problem remains. I have checked all my OneDrive settings and cannot find anything that would cause this problem. I have a Windows 11 laptop which is signed into the same Microsoft account and it does not have this problem. I’ve run out of ideas! Can anyone help? Thanks.  Read More

​