Applies to: Exchange Server 2010 SP3, Exchange Server 2010 SP2
Topic Last Modified: 2012-11-19
Use the Set-ThrottlingPolicy cmdlet to modify the settings for a throttling policy.
Syntax
Set-ThrottlingPolicy -Identity
<ThrottlingPolicyIdParameter> [-AnonymousMaxConcurrency
<UInt32>] [-AnonymousPercentTimeInAD <UInt32>]
[-AnonymousPercentTimeInCAS <UInt32>]
[-AnonymousPercentTimeInMailboxRPC <UInt32>] [-Confirm
[<SwitchParameter>]] [-CPAMaxConcurrency <UInt32>]
[-CPAPercentTimeInCAS <UInt32>] [-CPAPercentTimeInMailboxRPC
<UInt32>] [-CPUStartPercent <UInt32>]
[-DomainController <Fqdn>] [-EASMaxConcurrency
<UInt32>] [-EASMaxDeviceDeletesPerMonth <UInt32>]
[-EASMaxDevices <UInt32>] [-EASPercentTimeInAD
<UInt32>] [-EASPercentTimeInCAS <UInt32>]
[-EASPercentTimeInMailboxRPC <UInt32>]
[-EWSFastSearchTimeoutInSeconds <UInt32>] [-EWSFindCountLimit
<UInt32>] [-EWSMaxConcurrency <UInt32>]
[-EWSMaxSubscriptions <UInt32>] [-EWSPercentTimeInAD
<UInt32>] [-EWSPercentTimeInCAS <UInt32>]
[-EWSPercentTimeInMailboxRPC <UInt32>] [-ExchangeMaxCmdlets
<UInt32>] [-ForwardeeLimit <UInt32>]
[-IMAPMaxConcurrency <UInt32>] [-IMAPPercentTimeInAD
<UInt32>] [-IMAPPercentTimeInCAS <UInt32>]
[-IMAPPercentTimeInMailboxRPC <UInt32>] [-MessageRateLimit
<UInt32>] [-Name <String>] [-OWAMaxConcurrency
<UInt32>] [-OWAPercentTimeInAD <UInt32>]
[-OWAPercentTimeInCAS <UInt32>] [-OWAPercentTimeInMailboxRPC
<UInt32>] [-POPMaxConcurrency <UInt32>]
[-POPPercentTimeInAD <UInt32>] [-POPPercentTimeInCAS
<UInt32>] [-POPPercentTimeInMailboxRPC <UInt32>]
[-PowerShellMaxCmdletQueueDepth <UInt32>]
[-PowerShellMaxCmdlets <UInt32>]
[-PowerShellMaxCmdletsTimePeriod <UInt32>]
[-PowerShellMaxConcurrency <UInt32>]
[-PowerShellMaxDestructiveCmdlets <UInt32>]
[-PowerShellMaxDestructiveCmdletsTimePeriod <UInt32>]
[-PowerShellMaxTenantConcurrency <UInt32>]
[-RCAMaxConcurrency <UInt32>] [-RCAPercentTimeInAD
<UInt32>] [-RCAPercentTimeInCAS <UInt32>]
[-RCAPercentTimeInMailboxRPC <UInt32>] [-RecipientRateLimit
<UInt32>] [-WhatIf [<SwitchParameter>]]
|
Detailed Description
Throttling policy settings are stored in Active Directory. Although default throttling is always active, it's possible to configure the default policy not to do any throttling. We recommend configuring the default policy to include some throttling.
Note: |
---|
Unified Messaging users are considered Exchange Web Services users and are therefore throttled by Exchange Web Services parameters such as EWSMaxConcurrency, EWSPercentTimeInAD, EWSPercentTimeInCAS, and EWSPercentTimeInMailboxRPC. |
For more information, see Understanding Client Throttling Policies and Managing Performance with Client Throttling Policies.
You need to be assigned permissions before you can run this cmdlet. Although all parameters for this cmdlet are listed in this topic, you may not have access to some parameters if they're not included in the permissions assigned to you. To see what permissions you need, see the "Client throttling settings" entry in the Client Access Permissions topic.
Parameters
Parameter | Required | Type | Description | ||
---|---|---|---|---|---|
Identity |
Required |
Microsoft.Exchange.Configuration.Tasks.ThrottlingPolicyIdParameter |
The Identity parameter uniquely identifies the throttling policy that you want to modify values for. The name you use is the name of the throttling policy object in Active Directory. |
||
AnonymousMaxConcurrency |
Optional |
System.UInt32 |
The AnonymousMaxConcurrency parameter specifies how many
anonymous connections can be made to a user's calendar data at the
same time. A connection is held from the moment a request is
received until a response is sent in its entirety to the requestor.
If anonymous users attempt to make more concurrent requests than
their policy allows, the new connection attempt fails. However, the
existing connections remain valid. The
AnonymousMaxConcurrency parameter has a valid range from 0
through 2147483647 inclusive. The default value is 1. To indicate
that the number of concurrent connections should be unthrottled (no
limit), this value should be set to |
||
AnonymousPercentTimeInAD |
Optional |
System.UInt32 |
The AnonymousPercentTimeInAD parameter specifies the percentage of a minute that anonymous users can spend executing LDAP requests (PercentTimeInAD) to a user's calendar data. A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
AnonymousPercentTimeInCAS |
Optional |
System.UInt32 |
The AnonymousPercentTimeInCAS parameter specifies the percentage of a minute that anonymous users can spend executing Client Access server code (PercentTimeInCAS) to a user's calendar data. A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
AnonymousPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The AnonymousPercentTimeInMailboxRPC parameter specifies the percentage of a minute that anonymous users can spend executing mailbox RPC requests (PercentTimeInMailboxRPC) to a user's calendar data. A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
Confirm |
Optional |
System.Management.Automation.SwitchParameter |
The Confirm switch causes the command to pause processing and requires you to acknowledge what the command will do before processing continues. You don't have to specify a value with the Confirm switch. |
||
CPAMaxConcurrency |
Optional |
System.UInt32 |
The CPAMaxConcurrency parameter specifies how many
concurrent connections a cross-premises user can have against an
Exchange server at one time. A connection is held from the moment a
request is received until a response is sent in its entirety to the
requestor. If users attempt to make more concurrent requests than
their policy allows, the new connection attempt fails. However, the
existing connections remain valid. The CPAMaxConcurrency
parameter has a valid range from 0 through 2147483647 inclusive. To
indicate that the number of concurrent connections should be
unthrottled (no limit), this value should be set to
|
||
CPAPercentTimeInCAS |
Optional |
System.UInt32 |
The CPAPercentTimeInCAS parameter specifies the percentage of a minute that a cross-premises user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
CPAPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The CPAPercentTimeInMailboxRPC parameter specifies the percentage of a minute that a cross-premises user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
CPUStartPercent |
Optional |
System.UInt32 |
The CPUStartPercent parameter specifies the per-process
CPU percentage at which users governed by this policy begin to be
backed off. Valid values are from 0 through 100. Use
|
||
DomainController |
Optional |
Microsoft.Exchange.Data.Fqdn |
The DomainController parameter specifies the fully qualified domain name (FQDN) of the domain controller that writes this configuration change to Active Directory. |
||
EASMaxConcurrency |
Optional |
System.UInt32 |
The EASMaxConcurrency parameter indicates how many
concurrent connections a Microsoft Exchange ActiveSync user can
have against a server running Microsoft Exchange Server 2010 at one
time. A connection is held from the moment a request is received
until a response is sent in its entirety to the requestor. If users
attempt to make more concurrent requests than their policy allows,
the new connection attempt fails. However, the existing connections
remain valid. The EASMaxConcurrency parameter has a valid
range from 0 through 2147483647 inclusive. The default value is 10.
To indicate that the number of concurrent connections should be
unthrottled (no limit), this value should be set to
|
||
EASMaxDeviceDeletesPerMonth |
Optional |
System.UInt32 |
The EASMaxDeviceDeletesPerMonth parameter specifies a limit to the number of Exchange ActiveSync partnerships that a user can delete per month. By default, each user can delete a maximum of 20 partnerships per calendar month. When the limit is reached, the partnership deletion attempt fails and an error message is displayed to the user. |
||
EASMaxDevices |
Optional |
System.UInt32 |
The EASMaxDevices parameter specifies a limit to the number of Exchange ActiveSync partnerships that a user can have at one time. By default, each user can create 10 Exchange ActiveSync partnerships with their Exchange account. After users exceed the limit, they must delete one of their existing partnerships before they can create any more new partnerships. An e-mail error message describing the limitation is sent to the user when the limit is exceeded. Additionally, an event is logged in the Application log when a user exceeds the limit. |
||
EASPercentTimeInAD |
Optional |
System.UInt32 |
The EASPercentTimeInAD parameter specifies the percentage of a minute that an Exchange ActiveSync user can spend executing LDAP requests (PercentTimeInAD). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
EASPercentTimeInCAS |
Optional |
System.UInt32 |
The EASPercentTimeInCAS parameter specifies the percentage of a minute that an Exchange ActiveSync user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
EASPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The EASPercentTimeInMailboxRPC parameter specifies the percentage of a minute that an Exchange ActiveSync user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
EWSFastSearchTimeoutInSeconds |
Optional |
System.UInt32 |
The EWSFastSearchTimeoutInSeconds parameter specifies the amount of time that searches made using Exchange Web Services continue before they time out. If the search takes more than the time indicated by the policy value, the search stops and an error is returned. The default value of this setting is 60 seconds. |
||
EWSFindCountLimit |
Optional |
System.UInt32 |
The EWSFindCountLimit parameter specifies the maximum result size of FindItem or FindFolder calls that can exist in memory on the Client Access server at the same time for this user in this current process. If an attempt is made to find more items or folders than your policy limit allows, an error is returned. However, the limit isn't strictly enforced if the call is made within the context of an indexed page view. Specifically, in this scenario, the search results are truncated to include the number of items and folders that fit within the policy limit. You can then continue paging into your results set via further FindItem or FindFolder calls. |
||
EWSMaxConcurrency |
Optional |
System.UInt32 |
The EWSMaxConcurrency parameter specifies how many
concurrent connections an Exchange Web Services user can have
against an Exchange server at one time. A connection is held from
the moment a request is received until a response is sent in its
entirety to the requestor. If users attempt to make more concurrent
requests than their policy allows, the new connection attempt
fails. However, the existing connections remain valid. The
EWSMaxConcurrency parameter has a valid range from 0 through
2147483647 inclusive. The default value is 10. To indicate that the
number of concurrent connections should be unthrottled (no limit),
this value should be set to |
||
EWSMaxSubscriptions |
Optional |
System.UInt32 |
The EWSMaxSubscriptions parameter specifies the maximum number of active push and pull subscriptions that a user can have on a specific Client Access server at the same time. If a user tries to create more subscriptions than the configured maximum, the subscription fails, and an event is logged in Event Viewer. |
||
EWSPercentTimeInAD |
Optional |
System.UInt32 |
The EWSPercentTimeInAD parameter specifies the percentage of a minute that an Exchange Web Services user can spend executing LDAP requests (PercentTimeInAD). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
EWSPercentTimeInCAS |
Optional |
System.UInt32 |
The EWSPercentTimeInCAS parameter specifies the percentage of a minute that an Exchange Web Services user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
EWSPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The EWSPercentTimeInMailboxRPC parameter specifies the percentage of a minute that an Exchange Web Services user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
ExchangeMaxCmdlets |
Optional |
System.UInt32 |
The ExchangeMaxCmdlets parameter specifies the number of cmdlets that can be executed within a specific time period before their execution is slowed down. The value specified by this parameter should be less than the value specified by the PowerShellMaxCmdlets parameter. The time period used for this limit is specified by the PowerShellMaxCmdletsTimePeriod parameter. We recommend that you set values for both parameters at the same time. |
||
ForwardeeLimit |
Optional |
System.UInt32 |
The ForwardeeLimit parameter specifies the limits for the number of recipients that can be configured in Inbox Rules when using the forward or redirect action. This parameter doesn't limit the number of messages that can be forwarded or redirected to the recipients that are configured. |
||
IMAPMaxConcurrency |
Optional |
System.UInt32 |
The IMAPMaxConcurrency parameter specifies how many
concurrent connections an IMAP user can have against an Exchange
server at one time. A connection is held from the moment a request
is received until a response is sent in its entirety to the
requestor. If users attempt to make more concurrent requests than
their policy allows, the new connection attempt fails. However, the
existing connections remain valid. The IMAPMaxConcurrency
parameter has a valid range from 0 through 2147483647 inclusive. To
indicate that the number of concurrent connections should be
unthrottled (no limit), this value should be set to
|
||
IMAPPercentTimeInAD |
Optional |
System.UInt32 |
The IMAPPercentTimeInAD parameter specifies the percentage of a minute that an IMAP user can spend executing LDAP requests (PercentTimeInAD). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
IMAPPercentTimeInCAS |
Optional |
System.UInt32 |
The IMAPPercentTimeInCAS parameter specifies the percentage of a minute that an IMAP user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
IMAPPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The IMAPPercentTimeInMailboxRPC parameter specifies the percentage of a minute that an IMAP user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
MessageRateLimit |
Optional |
System.UInt32 |
The MessageRateLimit parameter specifies the number of messages per minute that can be submitted to transport. For messages submitted through the Mailbox server role (using Microsoft Outlook, Microsoft Office Outlook Web App, Exchange ActiveSync, or Exchange Web Services), this results in the deferral of messages until the quota for the user is available. Specifically, messages appear in the Outbox or Drafts folder for longer periods of time when users submit messages at a rate greater than the MessageRateLimit parameter. For POP or IMAP clients submitting messages directly to transport using SMTP, clients receive a transient error if they submit at a rate that exceeds the MessageRateLimit parameter. Exchange attempts to connect and send the messages at a later time. |
||
Name |
Optional |
System.String |
The Name parameter specifies the name of the object in Active Directory. The default policy is named DefaultThrottlingPolicy<GUID>. |
||
OWAMaxConcurrency |
Optional |
System.UInt32 |
The OWAMaxConcurrency parameter specifies how many
concurrent connections an Outlook Web App user can have against an
Exchange server at one time. A connection is held from the moment a
request is received until a response is sent in its entirety to the
requestor. If users attempt to make more concurrent requests than
their policy allows, the new connection attempt fails. However, the
existing connections remain valid. The OWAMaxConcurrency
parameter has a valid range from 0 through 2147483647 inclusive.
The default value is 5. To indicate that the number of concurrent
connections should be unthrottled (no limit), this value should be
set to |
||
OWAPercentTimeInAD |
Optional |
System.UInt32 |
The OWAPercentTimeInAD parameter specifies the percentage of a minute that an Outlook Web App user can spend executing LDAP requests (PercentTimeInAD). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
OWAPercentTimeInCAS |
Optional |
System.UInt32 |
The OWAPercentTimeInCAS parameter specifies the percentage of a minute that an Outlook Web App user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
OWAPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The OWAPercentTimeInMailboxRPC parameter specifies the percentage of a minute that an Outlook Web App user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
POPMaxConcurrency |
Optional |
System.UInt32 |
The POPMaxConcurrency parameter specifies how many
concurrent connections a POP user can have against an Exchange
server at one time. A connection is held from the moment a request
is received until a response is sent in its entirety to the
requestor. If users attempt to make more concurrent requests than
their policy allows, the new connection attempt fails. However, the
existing connections remain valid. The POPMaxConcurrency
parameter has a valid range from 0 through 2147483647 inclusive.
The default value is 20. To indicate that the number of concurrent
connections should be unthrottled (no limit), this value should be
set to |
||
POPPercentTimeInAD |
Optional |
System.UInt32 |
The POPPercentTimeInAD parameter specifies the percentage of a minute a POP user can spend executing LDAP requests (PercentTimeInAD). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
POPPercentTimeInCAS |
Optional |
System.UInt32 |
The POPPercentTimeInCAS parameter specifies the percentage of a minute a POP user can spend executing Client Access server code (PercentTimeInCAS). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
POPPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The POPPercentTimeInMailboxRPC parameter specifies the percentage of a minute a POP user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
PowerShellMaxCmdletQueueDepth |
Optional |
System.UInt32 |
The PowerShellMaxCmdletQueueDepth parameter specifies the number of operations allowed to be executed by the user. This value directly affects the behavior of the PowerShellMaxCmdlets and PowerShellMaxConcurrency parameters. For example, the PowerShellMaxConcurrency parameter consumes at least two operations defined by the PowerShellMaxCmdletQueueDepth parameter but additional operations are also consumed by per cmdlet execution. The number of operations depends on the cmdlets that are executed. We recommend that the value for the PowerShellMaxCmdletQueueDepth parameter be at least three times larger than the value of the PowerShellMaxConcurrency parameter. This parameter won't affect Exchange Control Panel operations or Exchange Web Services operations. |
||
PowerShellMaxCmdlets |
Optional |
System.UInt32 |
The PowerShellMaxCmdlets parameter specifies the number of cmdlets that can be executed within a specific time period before their execution is stopped. The value specified by this parameter should be more than the value specified by the ExchangeMaxCmdlets parameter. The time period used for this limit is specified by the PowerShellMaxCmdletsTimePeriod parameter. Both values should be set at the same time. |
||
PowerShellMaxCmdletsTimePeriod |
Optional |
System.UInt32 |
The PowerShellMaxCmdletsTimePeriod parameter specifies the time period, in seconds, that the throttling policy uses to determine whether the number of cmdlets being executed exceeds the limits specified by the PowerShellMaxCmdlets and ExchangeMaxCmdlets parameters. |
||
PowerShellMaxConcurrency |
Optional |
System.UInt32 |
The PowerShellMaxConcurrency parameter specifies different information depending on context:
This parameter value doesn't necessarily correlate to the number of browsers opened by the user. |
||
PowerShellMaxDestructiveCmdlets |
Optional |
System.UInt32 |
The PowerShellMaxDestructiveCmdlets parameter specifies the number of destructive cmdlets that can be executed within a specific time period before their execution is stopped. Destructive cmdlets are cmdlets that can make significant changes to user data and configuration settings in your Exchange organization. Throttling these cmdlets may help prevent accidental data loss. The following cmdlets are designated as destructive:
The time period used for this limit is specified by the PowerShellMaxDestructiveCmdletsTimePeriod parameter. Both values should be set at the same time. This feature isn't enabled by default. For more information, see the example later in this topic. |
||
PowerShellMaxDestructiveCmdletsTimePeriod |
Optional |
System.UInt32 |
The PowerShellMaxDestructiveCmdletsTimePeriod parameter specifies the time period, in seconds, that the throttling policy uses to determine how many destructive cmdlets can be run. You set a value for this parameter when set the PowerShellMaxDesctructiveCmdlets parameter. Both values should be set at the same time. For more information, see the description for the PowerShellMaxDesctructiveCmdlets parameter. |
||
PowerShellMaxTenantConcurrency |
Optional |
System.UInt32 |
The PowerShellMaxTenantConcurrency parameter limits the
number of concurrent Windows PowerShell connections per tenant
organization. By default, the limit for concurrent Windows
PowerShell connections per tenant organization is set to 9. If
users in a tenant organization try to make more concurrent requests
than the limit set by the PowerShellMaxTenantConcurrency
parameter, the new connection attempt fails. However, the existing
connections remain valid. This limit is enforced even if a single
user hasn't exceeded the per-user limit set by the
PowerShellMaxConcurrency parameter. The
PowerShellMaxTenantConcurrency parameter has a valid range
from 0 through 100 inclusive. To indicate that the number of
concurrent connections should be unthrottled (no limit), this value
should be set to
|
||
RCAMaxConcurrency |
Optional |
System.UInt32 |
The RCAMaxConcurrency parameter indicates how many
concurrent connections an RPC Client Access user can have against a
server running Exchange 2010 at one time. A connection is held from
the moment a request is received until the connection is closed or
the connection is otherwise disconnected (for example, if the user
goes offline). If users attempt to make more concurrent requests
than their policy allows, the new connection attempt fails.
However, the existing connections remain valid. The
RCAMaxConcurrency parameter has a valid range from 0 through
2147483647 inclusive. The default value is 20. To indicate that the
number of concurrent connections should be unthrottled (no limit),
this value should be set to |
||
RCAPercentTimeInAD |
Optional |
System.UInt32 |
The RCAPercentTimeInAD parameter specifies the percentage of a minute that an Outlook user can spend executing directory requests. A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
RCAPercentTimeInCAS |
Optional |
System.UInt32 |
The RCAPercentTimeInCAS parameter specifies the percentage of a minute that an Outlook user can spend executing Client Access server mailbox requests. A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
RCAPercentTimeInMailboxRPC |
Optional |
System.UInt32 |
The RCAPercentTimeInMailboxRPC parameter specifies the percentage of a minute that an RPC Client Access user can spend executing mailbox RPC requests (PercentTimeInMailboxRPC). A value of 100 indicates that for every one-minute window, the user can spend 60 seconds of that time consuming the resource in question. |
||
RecipientRateLimit |
Optional |
System.UInt32 |
The RecipientRateLimit parameter specifies the limits on the number of recipients that a user can address in a 24-hour period. |
||
WhatIf |
Optional |
System.Management.Automation.SwitchParameter |
The WhatIf switch instructs the command to simulate the actions that it would take on the object. By using the WhatIf switch, you can view what changes would occur without having to apply any of those changes. You don't have to specify a value with the WhatIf switch. |
Input Types
To see the input types that this cmdlet accepts, see Cmdlet Input and Output Types. If the Input Type field for a cmdlet is blank, the cmdlet doesn’t accept input data.
Return Types
To see the return types, which are also known as output types, that this cmdlet accepts, see Cmdlet Input and Output Types. If the Output Type field is blank, the cmdlet doesn’t return data.
Examples
EXAMPLE 1
This example modifies a throttling policy so that users associated with this policy can have a maximum of four concurrent requests running in Exchange Web Services.
Copy Code | |
---|---|
Set-ThrottlingPolicy -EWSMaxConcurrency 4 |
EXAMPLE 2
This example modifies a throttling policy so that users associated with the default policy can have a maximum of four concurrent requests running in Exchange Web Services.
Copy Code | |
---|---|
$a = Get-ThrottlingPolicy | where-object {$_.IsDefault -eq $true} $a | Set-ThrottlingPolicy -EWSMaxConcurrency 4 |
EXAMPLE 3
This example modifies a throttling policy so that it restricts the number of connections for a user to three. The users associated with this policy are only able to create three Exchange Management Shell sessions. This policy also restricts to three the number of Exchange Control Panel operations or Exchange Web Services operations that can be executed at the same time.
Copy Code | |
---|---|
Set-ThrottlingPolicy <PolicyName> -PowerShellMaxConcurrency 3 -PowerShellMaxCmdletQueueDepth 12 |
EXAMPLE 4
This example assigns ClientThrottlingPolicy2 to the user tonysmith.
Copy Code | |
---|---|
$b = Get-ThrottlingPolicy ClientThrottlingPolicy2 Set-Mailbox -Identity tonysmith -ThrottlingPolicy $b |
EXAMPLE 5
This example modifies a throttling policy so that it restricts a user to be able to execute only 10 destructive cmdlets in 60 seconds. If the users associated with this policy exceed this number, the cmdlet pipeline execution is stopped with a throttling error message. The user needs to wait for and then resubmit the execution of cmdlets on the open connection.
Copy Code | |
---|---|
Set-ThrottlingPolicy <ThrottlingPolicyName> -PowerShellMaxDestructiveCmdlets 10 -PowerShellMaxDestructiveCmdletsTimePeriod 60 |