BassemE/mulesoft-documentation-embeddings huggingface dataset:
Collaborating With Your API Portal Community | MuleSoft Documentation
# Collaborating With Your API Portal Community
You can enable collaboration with members of an API portal community using Salesforce Chatter Feed components to:
  * Sharing posts and updates
  * Participating in polling
  * Asking questions
  * Receiving notifications for relevant activities in personalized feeds


The Chatter Feed options that display depend on how your administrator sets up feeds for the API portal.
To see feedback and discussions about an API:
  1. Select an API from the **Home** or **APIs** page of the portal.
  2. In the **API details** page, select the **Feedback and discussions** tab.
**Feedback and discussions** is the default of name of the tab, however, administrators can change this name.


For more information about using Chatter Feed tracking, see the following Salesforce documentation:
  *   *   *   *
Manual Migration Process | MuleSoft Documentation
# Manual Migration Process
After learning how to prepare for a migration, it is important to understand the high-level migration steps. 

Note
    
For an assisted migration with the Mule Migration Assistant, start instead from the user documentation (on GitHub), which links to the MMA user documentation.
For a completely manual migration:
  1. Add all required modules, such as the Database connector, to the Anypoint Studio 7 palette.
Notes:
     * You can add modules through the Studio 7 palette. Other modules are available in Anypoint Exchange.
     * All Mule projects are Mavenized by default when you add the modules to your project.
  2. Migrate all the global configurations.
  3. Migrate configuration properties.
  4. Learn how the components work in Mule 4 to see what has changed from Mule 3.
  5. Understand how changes to the Mule message structure (attributes, payload, and variables) affect your configurations. See Introduction to Mule 4: The Mule Message.
  6. Update your expressions and scripts to DataWeave version 2:
     * Be aware of changes between DataWeave 1 and DataWeave 2, for example, importing specific function modules and understanding syntax changes. See Migrating from DataWeave 1.0 to 2.x.
     * Change MEL expressions to DataWeave 2, for example, in an connector or Choice component. See Migrating MEL to DataWeave.
  7. Update all exception handling to Mule 4 with the new exception types that are available.
  8. If you are working with APIs, understand how to set HTTP status codes.


## See Also
Preparing for the Migration
Introduction to Mule 4
Rename a Project | MuleSoft Documentation
# Rename a Project
You can rename an API-specification project or an API-fragment project. If you have already published a project, renaming it does not create a new asset in Exchange when you publish the project again.
## Procedure
To rename a project, use one of these methods:
  * If the project is not open, select the project in Design Center’s **Projects** page, and then click the Edit icon in the top-right corner of the page.
  * If the project is open. click the gear icon in API Designer’s top-right corner and then select **Rename**.
Using the Browser Wizard | MuleSoft Documentation
# Using the Browser Wizard
The _Browser Wizard_ is part of _Web Automation action step_ wizards. It behaves like a normal browser and enables you to select additional elements of a website and determine their _Xpath_. Using the _Browser Wizard_ is required by most _Web Automation_ objects embedded in a _Web Session_.
Clicking the **Open Browser Wizard** button in one of the wizards opens a new window that functions as a browser and loads the URL that is defined as the initial URL for the enclosing _Web Session_.
If you start the _Web Session_ with `about:blank`, you can enter a URL in the address bar of the _Browser Wizard_ and the wizard loads this URL when you press _Enter_.
## Selecting Web Elements
When you position the cursor over the element you want to check or use within a _Web Automation_ object, the wizard highlights the element with a blue background. If hovering over the elements does not highlight them, click on the website or web application within the _Browser Wizard_ to activate it first.
To select the highlighted element press _F2_. After selecting an element, its background turns blue and the _XPath_ and available attributes corresponding to this element show on the Properties panel.
## Browser Wizard Toolbar
The following list describes the buttons of the _Browser Wizard_ toolbar:
  * (): Navigates back.
  * (): Navigates forward.
  * (): Reloads the current page.
  * (): Clears the browser cache data and Cookies.
  * (): Confirms the selection and extracts the _XPath_ of the selected element along with the current input as values. This option is available only in the **Keystrokes to Web Element** Wizard.
  * (): Confirms the selection and extracts the _XPath_ of the selected element.


## See Also
  * Common Properties (Web Automation)
  *   *   *
Transit Gateway Attachments | MuleSoft Documentation
# Transit Gateway Attachments
AWS Transit Gateway acts as a cloud router in AWS, simplifying network access between private spaces, on-premises data centers, and third-party software, while providing increased visibility and control over the network. Transit gateways effectively merge your organization’s cloud resources and on-premises datacenters into one network topology.
On CloudHub 2.0, you can take advantage of this network simplification by securely attaching your private space to AWS Transit Gateway in your AWS account.
You can add multiple transit gateways to your Anypoint Platform organization. The number of transit gateways you can add depends on the network connection entitlements available to your account. Contact your MuleSoft account representative if you don’t know how many entitlements are associated with your account.
To use transit gateway attachments, your private space and AWS Transit Gateway must be in the same region.
To attach your private space to your transit gateway, see Create a Connection to an External Network.
## Limitations
The following limits are governed by AWS limits:
  * Maximum number of transit gateways per VPC
  * Maximum number of VPCs that you can attach to a transit gateway


For information about limitations when attaching a VPC to a transit gateway, see Transit gateway attachments to a VPC in the AWS documentation.
## See Also
  * What is a transit gateway? in the AWS documentation
  * Transit gateway route tables in the AWS documentation
Adding Compatible Java Versions for Assets Using the Maven Client | MuleSoft Documentation
# Adding Compatible Java Versions for Assets Using the Maven Client
Add the compatible Java versions of assets for Anypoint Platform Private Cloud Edition (Anypoint Platform PCE) using the Maven Facade API (v1 and v2). The Java versions display in the Exchange UI, Exchange API, and GraphQL console for Anypoint Platform PCE environments. Only Java 8, 11, and 17 are supported.
To add the Java version compatibility, in the POM file, add the properties section and set each Java version to either true or false.
This example snippet shows the properties section:
```
<properties>
  <type>app</type>
  <tags>connector, mulesoft</tags>
  <isJava8Supported>false</isJava8Supported>
  <isJava11Supported>true</isJava11Supported>
  <isJava17Supported>true</isJava17Supported>
</properties>
```

In the example, Java 8 is set to `false`. Only version 11 and 17 appear for the asset version in the Exchange UI, Exchange API, and the GraphQL console.
## See Also
  * Managing Anypoint Platform PCE
Creating New GitHub Repositories Synchronized from an Existing Projects | MuleSoft Documentation
# Creating New GitHub Repositories Synchronized from an Existing Projects
You can create a new GitHub repository and synchronize it with an existing API Designer project.
## Before You Begin
Before you synchronize a new repository and a project, ensure you have:
  * The Design Center Developer permission within Anypoint Platform
  * Installed and authorized the GitHub Synchronization application
  * Signed into GitHub


## Synchronize A New Repository and A Project
  1. In the Design Center **Projects** list, click the table row containing a project to synchronize with GitHub.
  2. In the details panel, click the **Sync with GitHub** button.
  3. In the **Enable Sync with GitHub** dialog, select an organization from the **GitHub Organization** list dropdown.
The **GitHub Organization** list remains empty if the GitHub Synchronization application is not installed. See Install and Authorize the MuleSoft GitHub Synchronization Application.   
---  
  4. Specify a name for the new repository.
  5. Click **Sync**.
You are navigated to the Design Center **Projects** page. A **Sync Status** indicator appears in the **Details** pane along with buttons that enable you to manage a GitHub repository and disable synchronizing.


## See Also
  * Create an API Specification with the Text Editor
  * Helpful Features in the Text Editor
  * Publish an API Specification
Metrics Not Showing for Applications | MuleSoft Documentation
# Metrics Not Showing for Applications
If the metrics aren’t showing for client applications on the **My Applications** details page, you may not have the proper permissions to view the metrics. Ensure that you have the **Monitoring Viewer** permissions.
  1. Log in to Anypoint Platform and go to **Access Management**.
  2. Select **Teams** and select **Community Users**.
  3. Select the **Permissions** tab, locate the business group, and click **Edit**.
  4. If **Monitoring Viewer** is not in the list, click **Done**.
  5. Click **Add permissions** and select **Anypoint Monitoring** > **Monitoring Viewer**.
  6. Click **Next**.
  7. Select all business groups that apply and click **Next**.
  8. Click **Add Permissions**.
XML Threat Protection Policy | MuleSoft Documentation
# XML Threat Protection Policy
**Policy Name** | XML Threat Protection  
---|---  
Protects against malicious XML in API requests  
Security  
**First Flex Gateway version available**  
**Returned Status Codes** | 400 - Bad Request  
## Summary
Applications that process XML requests are susceptible to attacks characterized by unusual inflation of elements, attributes, and deep nesting levels. Attackers use recursive techniques to consume memory resources. Dramatic increases in the size of the application data often signal a security risk. Use the XML Threat Protection policy to reject unusual requests that exceed the defined expected size.
## Configuring Policy Parameters
### Flex Gateway Local Mode
In Local Mode, you apply the policy to your API via declarative configuration files. Refer to the following policy definition and table of parameters:
```
- policyRef:
  name: xml-threat-protection-flex
 config:
  maxNodeDepth: <number> // OPTIONAL, default: -1
  maxAttributeCountPerElement: <number> // OPTIONAL, default: -1
  maxChildCount: <number> // OPTIONAL, default: -1
  maxTextLength: <number> // OPTIONAL, default: -1
  maxAttributeLength: <number> // OPTIONAL, default: -1
  maxCommentLength: <number> // OPTIONAL, default: -1
```

Defining a parameter as `-1` means the parameter has no limit.   
---  
Parameter | Required | Default Value | Description  
---|---|---|---  
`maxNodeDepth` |  Specifies the maximum node depth of an XML document.  
`maxAttributeCountPerElement` |  Specifies the maximum number of attributes in an element. Attributes used for defining namespaces are not counted.  
`maxChildCount` |  Specifies the maximum number of children of an element in the XML document.  
`maxTextLength` |  Specifies the maximum length in characters of text nodes in the XML document.  
`maxAttributeLength` |  Specifies the maximum length in characters of an attribute in the XML document.  
`maxCommentLength` |  Specifies the maximum number of comment characters in the XML document.  
#### Resource Configuration Example
```
- policyRef:
  name: xml-threat-protection-flex
 config:
  maxNodeDepth: 1
  maxAttributeCountPerElement: 1
  maxChildCount: 2
  maxTextLength: 20
  maxAttributeLength: 20
  maxCommentLength: 20
```

### Managed Flex Gateway and Flex Gateway Connected Mode
When you apply the policy to your API instance from the UI, the following parameters are displayed:
Field | Description  
---|---  
Maximum Node Depth |  Specifies the maximum node depth of an XML document.  
Maximum Attribute Count Per Element |  Specifies the maximum number of attributes in an element. Attributes used for defining namespaces are not counted.  
Maximum Child Count |  Specifies the maximum number of children of an element in the XML document.  
Maximum Text Length |  Specifies the maximum length in characters of text nodes in the XML document.  
Maximum Attribute Length |  Specifies the maximum length in characters of an attribute in the XML document.  
Maximum Comment Length |  Specifies the maximum number of comment characters in the XML document.
Defining Parameters in a Message Source | MuleSoft Documentation
# Defining Parameters in a Message Source
Parameters are defined as fields of your `Source` class. All the features and annotations (such as `@NullSafe`, `@ParameterGroup`, `@TypeResolver`) are available when defining an operation, for example:
```
@EmitsResponse
public class HttpListener extends Source<InputStream, HttpRequestAttributes> {
  @Config
  private HttpListenerConfig config;
  @Parameter
  @Optional(defaultValue = "/")
  private String path;
  @Parameter
  private Integer port;
  /**
  * Comma separated list of allowed HTTP methods by this listener.
  */
  @Parameter
  @Optional
  @Placement(tab = Placement.ADVANCED_TAB)
  @Summary("Comma separated list of methods. Leave empty to allow all.")
  @Example("GET, POST")
  private String allowedMethods;
}
```

This is similar to how configs are defined, except that none of these parameters accept expressions. Using the `@Expression` annotation to support or require expression support results in an error.
## Next step
  * Lifecycle of a Message Source
Apply Environment Settings | MuleSoft Documentation
# Apply Environment Settings
You can apply changes to your environment’s Partner Manager or Access Management settings, like Mule runtime version or vCore and ActiveMQ configurations, to all your runtime applications at once. Follow these steps to apply the changes:
  1. From the Message flows page, click **Manage deployments**.
  2. Select **Apply runtime settings**.
  3. Check the box to confirm that you understand the effects of these actions.
  4. Click **Confirm**.


Applying environment settings updates all the Mule applications in your runtime with the latest available template versions.
Prevent the SOAP Fault | MuleSoft Documentation
# Prevent the SOAP Fault
After resolving the generated SOAP fault, add the Transform Message component to the flow and specify a message in DataWeave to respond to the request and implement the operation. In the DataWeave code, use the proper `namespace` to avoid a fault code at the beginning of the response to the request.
The Transform Message component works on the process side after you reach the endpoint defined in the WSDL. This action triggers the execution of the main flow of the Mule application, which calls the backend flow.
  1. In Studio, in the **OrderTshirt:\soapkit-config** flow, open the Transform Message component.
The Transform Message properties window displays the generated DataWeave code.
  2. Modify the DataWeave code as follows:
```
%dw 2.0
output application/java
ns ns0 http://mulesoft.org/tshirt-service
---
{
  body: {
    ns0#OrderTshirtResponse: {
      orderId: "I got a request from " ++ (payload.body.ns0#OrderTshirt.name default "")
    }
  } write "application/xml"
}
```

  3. Save and rerun the project.
  4. In SoapUI, resubmit the request to generate a SOAP fault.
The output changes to a valid response:


```
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
   <ns0:OrderTshirtResponse xmlns:ns0="http://mulesoft.org/tshirt-service">
     <orderId>I got a request from John</orderId>
   </ns0:OrderTshirtResponse>
  </soap:Body>
</soap:Envelope>
```

## See Also
  * Display a Typed Fault
Configuring Mutual Authentication with Anypoint Platform | MuleSoft Documentation
# Configuring Mutual Authentication with Anypoint Platform
Mutual authentication for connectivity between Runtime Fabric and the Anypoint Platform control plane is enabled by default for Runtime Fabric versions 1.6.45 and later. The following instructions to enable mutual authentication apply only to those versions earlier than 1.6.45.  
---  
Mutual authentication improves the security of communication between Runtime Fabric and Anypoint Platform and is highly recommended.
For Runtime Fabric versions earlier than 1.6.45, enable mutual authentication using the Runtime Fabric API. For Runtime Fabric versions 1.3.60 and later, use Runtime Manager to enable it.
## Before You Begin
Before enabling mutual authentication, verify the following endpoint and port are reachable from all Runtime Fabric controller and worker nodes:
  * US control plane:
    * `configuration-resolver.prod.cloudhub.io:443`
  * EU control plane:
    * `configuration-resolver.prod-eu.msap.io:443`


Failure to meet these requirements before enabling mutual authentication results in errors with creating and managing application deployments on Runtime Fabric.
You can use the latest version of the rtfctl utility to validate that all required endpoints are reachable from each Runtime Fabric controller node:
```
cd /opt/anypoint/runtimefabric
./rtfctl update
./rtfctl test outbound-network --mutual-tls-check
```

## Enable Mutual Authentication from Runtime Manager
  1. From Runtime Manager, select the appropriate environment and click **Runtime Fabrics**.
  2. Select a Runtime Fabric.
  3. For **Enable mutual authentication with Anypoint Platform connectivity** , set the toggle to **On**.


## Enable Mutual Authentication using the Runtime Fabric API
From a Runtime Fabric workstation, run the following cURL command:
```
curl --location --request PATCH 'https://[eu1]anypoint.mulesoft.com/runtimefabric/api/organizations/<ORG-ID>/fabrics/<RUNTIME-FABRIC-ID>' --header 'Content-Type: application/json' --header 'Authorization: Bearer <TOKEN>' --data-raw '{"features": {"enhancedSecurity": true}}'
```

Replace these placeholders with your unique values:
  * <ORG-ID>
  * <RUNTIME-FABRIC-ID>
  * <TOKEN>
Troubleshooting WebSockets Connector | MuleSoft Documentation
# Troubleshooting WebSockets Connector
To troubleshoot Anypoint Connector for WebSockets (WebSockets Connector), become familiar with the information about enabling verbose logging and interpreting commonly thrown messages.
## Enable Verbose Logging
To get a better understanding of why an application’s interaction with WebSockets Connector is failing, temporarily enable verbose logging for the connector.
Remember to always disable the enhanced verbosity after troubleshooting because it affects your Mule application performance.
To enable verbose logging in the configuration file:
  1. Access Anypoint Studio and navigate to the **Package Explorer** view.
  2. Open your application’s project name.
  3. Open the `src/main/resources` path folder.
  4. Open the `log4j2.xml` file inside the folder.
  5. Add an `<AsyncLogger>` tag inside the `<Loggers>` tag:
```
			<Loggers>
				...
				<AsyncLogger name="com.mulesoft.connectors.ws" level="DEBUG"/>
				...
			</Loggers>
```

  6. Save your application changes.
  7. Click the project name in **Package Explorer** and then click **Run** > **Run As** > **Mule Application**.


## Understand Common Throws
Here is a list of common throw messages and how to interpret them:
  * WEBSOCKET:CONNECTIVITY
```
The connection is no longer valid. Apply a reconnection policy if defined in the application setup.
```

  * WEBSOCKET:RETRY_EXHAUSTED
```
The maximum number of retries for the operation is reached.
```

  * WEBSOCKET:NO_SUCH_SOCKET
```
The WebSocket cannot be referenced because the WebSocket ID does not exist.
```

  * WEBSOCKET:BASIC_AUTHENTICATION
```
The HTTP *Request* operation lacks basic authentication to send requests to the service, or the provided credentials are incorrect.
```

  * WEBSOCKET:FORBIDDEN
```
The server refuses to give the requested resource because the client does not have access rights to the content.
```

  * WEBSOCKET:INTERNAL_SERVER_ERROR
```
The server encountered a problem that prevented it from fulfilling the request.
```

  * WEBSOCKET:INVALID_SOCKET_ID
```
The WebSocket ID is null or blank.
```

  * WEBSOCKET:NON_UNIQUE_SOCKET_ID
```
An error occurred while registering the WebSocket because the ID already exists.
```

  * WEBSOCKET:NOT_FOUND
```
The server could not find the requested resource.
```

  * WEBSOCKET:REMOTELY_CLOSED
```
The remote host closed the connection, which could be related to an SSL/TLS handshake issue. Check protocols, cipher suites, and certificate setup. Use -Djavax.net.debug=ssl for further debugging.
```

  * WEBSOCKET:SERVICE_UNAVAILABLE
```
The server is unable to manage the request because it is down for maintenance or overloaded.
```

  * WEBSOCKET:UNAUTHORIZED
```
The authentication failed or has not yet been provided to get the requested response.
```



## See Also
  * WebSockets Connector Reference
  * MuleSoft Help Center
  *
Variable | MuleSoft Documentation
# Variable
This action step makes it possible to set up a simple string variable. This variable can also be made available globally for the entire _Workflow_ under Properties and "Make Variable available in all Transactions". Other variables can be used as Inbound Variables and therefore made global.
## Properties
**Variable Value** Defines the variable value which can be mapped onto another variable.
**Make Variable available in all Transactions** Makes the variable available for the entire _Workflow_ in all transactions. Variables are normally only available within their transaction.
## Inbound Variables
**Suffix** can be used if the _Variable_ is located within the _Control Block’s_ _File Controlled Loop_**.** A suffix is then added to the name of the _Variable_ during every loop _._ Each suffix is a column entry in the file that was imported in the _File Controlled Loop_.
**Variable Value** Defines the variable value which can be mapped onto another variable.
## Outbound Variables
**Value** Returns the current value of the _Variable._
Microsoft .NET Connector 3.1 | MuleSoft Documentation
# Microsoft .NET Connector 3.1
Anypoint Connector for Microsoft .NET (Microsoft .NET Connector) enables you to execute native .NET code in a Mule application. Microsoft .NET Connector has a dependency on the .NET CLR, which is available only on Windows machines.
This connector executes .NET code using Java Native Interface (JNI), which provides fast interprocess communication between Java Virtual Machine (JVM) and a native application that runs in a host operating system.
The connector supports one operation, **Execute** , which enables users to select a class and method to execute, and to pass the corresponding arguments for that method.
This connector supports standalone deployments only. This connector does not support CloudHub or Runtime Fabric deployments.  
---  
## Before You Begin
To use this connector, you must be familiar with:
  * The .NET API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to:
  * The .NET target resource
  * Anypoint Studio version 4.1.1 or later


## Common Use Cases for the Connector
Common use cases for this connector include:
  * Executing code in an existing binary assembly (DLL) without modification
  * Developing new .NET code that extends the capability of your integration application


For examples, see Examples.
## Audience
  * New users, read:
    * Using Anypoint Studio to Configure the Connector to create your Mule app
    * Examples, which provides one or more use cases for the connector
  * Advanced users, read:
    * XML and Maven Support
    * Examples, which provides one or more use cases for the connector


## Next Step
After you complete the prerequisites and experiment with examples, you are ready to create your own app and configure the connector using Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
DataWeave Overview | MuleSoft Documentation
# DataWeave Overview
DataWeave is the programming language designed by MuleSoft for data transformation. It is also the expression language Mule runtime engine uses to configure components and connectors.
DataWeave enables you to build a simple solution for a common use case for integration developers: read and parse data from one format, transform the data, and write it out as a different format. For example, a DataWeave script can receive a CSV file as input and transform it into an array of complex JSON objects, or receive an XML input and write the data out to a flat file format. DataWeave enables developers to focus on the transformation logic instead of thinking about the specifics of reading, parsing, and writing specific data formats in a performant way.
  * To learn more about DataWeave, visit the language guide.
  * To look up reference information about DataWeave 2.4.0 operators and functions, visit the reference guide.
  * To see sample scripts to solve common transformation scenarios, visit DataWeave examples.
  * To try DataWeave scripts interactively, visit DataWeave Playground.
  * To get started with DataWeave 2.4.0 for Mule runtime engine (Mule) version 4.4 and later, visit the quickstart.


## Compatibility
The following table specifies which version of DataWeave is bundled with each Mule runtime engine release:
Mule Version | DataWeave Version  
---|---
Viewing Runtime Fabric Health Details | MuleSoft Documentation
# Viewing Runtime Fabric Health Details
You can use Anypoint Runtime Manager to view the health of your Anypoint Runtime Fabric clusters.
## Health Details
For Runtime Fabric version 1.5 or later:
  1. Navigate to Runtime Manager and select **Runtime Fabric**.
  2. Select the name of your Runtime Fabric cluster to open the management page.
  3. Select **Health Details**.
The **Health Details** section indicates whether your Runtime Fabric cluster configuration meets the requirements for a production environment, a development environment, or neither. If your configuration fails to meet the minimum requirements of both production and development environments, `Not supported` is displayed.
Deprecating an API instance on API Manager | MuleSoft Documentation
# Deprecating an API instance on API Manager
While transitioning consumers of your API to an updated instance, you can prevent developers from signing up for access to your old API instance. As an API administrator, you mark an API as deprecated to remove the invitation for developers to request access from the portal page. Existing application contracts remain active but no new contracts can be created for that API instance. Deprecated APIs have an indicator in any location where they appear showing they are deprecated. A badge in search results indicates that the instance is deprecated.
  1. Navigate to **Anypoint Platform** > **API Manager**.
  2. In **API Administration** , click the name of the API instance you want to deprecate.
  3. Select **Actions** > **Deprecate API**.
  4. Click **Ok**.
The API is now deprecated.


## See Also
  * About Sharing Assets, including an API
  * To Request Access to an API
Shared Storage Models | MuleSoft Documentation
# Shared Storage Models
When configuring shared storage, MuleSoft recommends placing the Redis shared storage service as close to Flex Gateway as possible.
If the Redis shared storage service is available locally in the same cluster or the same Virtual Private Cloud (VPC), a mutual authentication Transport Layer Security (mTLS) connection is not required to communicate with the shared storage.
To configure the connection between Flex Gateway and the shared storage service, see:
  * Configure Shared Storage in Connected Mode
  * Configure Shared Storage in Local Mode


The following diagrams use Kubernetes terminology, but you can extend the architecture to other technology stacks that have the appropriate network controls applied.
You can place the Redis shared storage within the same Kubernetes cluster as Flex Gateway or instantiated within the same VPC as Flex Gateway:
## Shared Storage in the Same Cluster
## Shared Storage in the Same VPC
## See Also
  * Configure Shared Storage in Connected Mode
  * Configure Shared Storage in Local Mode
  * Configuring Flex Gateway Configuration Caching in Connected Mode
CloudHub 2.0 Release Notes | MuleSoft Documentation
# CloudHub 2.0 Release Notes
  * CloudHub 2.0 Feature Release Notes
  * CloudHub 2.0 Runtime Release Notes
  * Anypoint VPN Updates Release Notes


## See Also
  * CloudHub 2.0 Documentation
To Test External Identity | MuleSoft Documentation
# To Test External Identity
After configuring your organization’s external identity provider, test the integration. Obtain your organization’s signin URL, for example: `https:/anypoint.mulesoft.com/accounts/login/{organization-domain-name}` by following these steps:
  1. Sign in to Anypoint Platform using an account that has the root Organization Administrator permission.
  2. In the navigation bar or the main Anypoint Platform page, click **Access Management**.
  3. In the Access Management navigation menu, click **Business Groups**.
  4. Click the name of your root organization.
  5. Click the **Settings** tab.
  6. Copy your organization name from the Domain Name field.
  7. Sign out of your Organization Administrator account in Anypoint Platform.
  8. Navigate to your organization’s signin URL.
You are redirected to your identity provider.
  9. Sign in to your identity provider with a test user managed by your identity provider.
After authenticating, you are redirected back to Anypoint Platform as an authenticated user.
FHIR R4 Assets | MuleSoft Documentation
# FHIR R4 Assets
The following are a collection of assets to support MuleSoft customers who are developing Fast Healthcare Interoperability Resources (FHIR) APIs using MuleSoft. Visit the official HL7 website for more information.
  * FHIR RAML auto-generator - Utility to generate RAML specifications for FHIR resources from the JSON schema provided by HL7.
  * FHIR R4 US Core Profile Assets - A collection of API specifications, data types, and libraries designed to meet FHIR USCDI Core Profile compliance standards.
  * FHIR R4 Resources List - A collection of API specifications, data types, and libraries designed to align to the FHIR R4 base standard.
  * FHIR Error API Policy - A custom policy that captures error responses and transforms them into an FHIR compliant `OperationOutcome` format. This policy can also be used with other out-of-the-box API policies provided in Anypoint Platform, such as OAuth or JWT.
  * Okta SMART on FHIR - Guidance for setting up a reference "SMART on FHIR" implementation on Anypoint Platform using Okta as the identity provider.


## See Also
  *   *   * MuleSoft Accelerator for Healthcare
Licensing | MuleSoft Documentation
# Licensing
Licenses are procured and provisioned by MuleSoft. API Experience Hub requires two types of licenses:
  * Salesforce
This license is required to use the Salesforce Experience Builder.
  * External Identity
This license is based on the number of member requests to access the portal. The current package has a minimum of 100 API access requests which require a minimum of 2000 External Identity licenses. This is required for the portal consumers to access the API portal.


To set up an organization, you can have the following Salesforce editions:
  * Unlimited Edition
  * Enterprise Edition
  * Performance Editions of Salesforce
Salesforce CDP Connector 1.0 | MuleSoft Documentation
# Salesforce CDP Connector 1.0
Anypoint Connector for Salesforce CDP (Salesforce CDP Connector) provides customers a pipeline to send data from both non-Salesforce and Salesforce properties alike into Salesforce CDP.
This connector works with the Salesforce CDP Bulk and Streaming API, depending on the operation you configure. Each API call uses a request/response pattern over an HTTPS connection. All required request headers, error handling, and HTTPS connection configurations are built into the connector. For information about compatibility and fixed issues, see the Salesforce CDP Connector Release Notes.
## Before You Begin
To use this connector, you must be familiar with:
  * The Salesforce CDP API
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * How to create a Mule app using Anypoint Studio


Before creating an app, you must have:
  * Set up the Ingestion API
  * Credentials to access the Salesforce CDP target resource
  * Anypoint Platform
  * Anypoint Studio version 7.3.x or later


## Set Up the Ingestion API
To use Salesforce CDP Connector, you must first set up the Ingestion API. For more information, refer to Connect MuleSoft with Customer Data Platform.
After setting up the Ingestion API, refer to Next Step to configure your connector.
## Common Use Cases For the Connector
These are some common use cases for Salesforce CDP Connector:
  * Stream data via upsert and delete object endpoints of the Ingestion API Connector
  * Query CDP objects
  * Create a bulk job, upload job data, close/abort the job, get job status and delete the job


For examples, see Salesforce CDP Connector Examples use cases.
## Connection Types
Salesforce CDP connections use the following authentication types:
  * OAuth JWT Uses OAuth 2.0 with a JSON Web token (JWT) request for user authentication
  * OAuth Username Password Uses OAuth 2.0 with a user and password for authentication


For information about configuring authentication types, see Using Anypoint Studio to Configure Salesforce CDP Connector.
## Next Step
After you complete the prerequisites, you are ready to create an app and configure the connector using Anypoint Studio.
## See Also
  *   * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * Salesforce CDP Connector Reference
  * MuleSoft Help Center
SFTP Connector | MuleSoft Documentation
# SFTP Connector
Anypoint Connector for SFTP (SFTP Connector) provides access to files and folders on an SFTP server. SFTP connector operations manage file transfers over the SFTP (Secure File Transfer Protocol) protocol. The connector’s main features include:
  * The ability to read files or list directory contents on demand
  * Support for common SFTP operations such as creating directories, copying, moving, renaming, and deleting files
  * Support for locking files
  * File matching functionality
  * A design that is consistent with that of File Connector and FTP Connector
The same set of operations is available on these connectors, and they behave similarly.


## Representation of File Attributes
Mule 4 provides a message structure of a payload and attributes in which the data moves around, making that payload a file content. The attributes provide an object that contains metadata on the payload and information such as the file’s name, path, size, and timestamps. For FTP Connector and SFTP Connector, these attributes are known as _file attributes_.
The Mule message contains the concepts of encoding and MIME type. These describe the format in which a payload is represented. The file attributes describe a file’s encoding and MIME type.
## Before You Begin
To use this connector, you must be familiar with:
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to Anypoint Platform and Anypoint Studio.
## Next Step
After you complete the prerequisites, you are ready to create your own app and configure the connector using Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
hours | MuleSoft Documentation
# hours
## hours(nHours: Number): Period
Creates a Period value from the provided number of hours.
The function applies the `duration` function to the input value.
_Introduced in DataWeave version 2.4.0._
### Parameters
Name | Description  
---|---  
The number of hours as a whole or decimal number. A positive or negative number is valid.  
### Example
This example shows how `hours` behaves with different inputs. It adds and subtracts hours from DateTime and LocalTime values. It also converts the decimal value `4.555` into the Period format (`PT4H33M18S`) and the whole number `4` into the Period format (`PT4H`). Notice that `hours(-1) + hours(2)` returns the number of seconds.
#### Source
```
%dw 2.0
import * from dw::core::Periods
output application/json
---
{
  nextHour: |2020-10-05T20:22:34.385Z| + hours(1),
  previousHour: |2020-10-05T20:22:34.385Z| - hours(1),
  threeHoursLater: |20:22| + hours(3),
  addDecimalInput: |20:22| + hours(3.5),
  decimalInputAsPeriod : hours(4.555),
  fourHourPeriod : hours(4),
  addNegativeValue: hours(-1) + hours(2)
}
```

#### Output
```
{
  "nextHour": "2020-10-05T21:22:34.385Z",
  "previousHour": "2020-10-05T19:22:34.385Z",
  "threeHoursLater": "23:22:00",
  "addDecimalInput": "23:52:00",
  "decimalInputAsPeriod": "PT4H33M18S",
  "fourHourPeriod": "PT4H",
  "addNegativeValue": 3600
}
```
File Connector | MuleSoft Documentation
# File Connector
Anypoint Connector for File (File Connector) manages files and folders on a locally mounted file system. The connector’s main features include:
  * The ability to read files or fully list directory contents on demand
  * Support for common file operations such as creating directories, reading, writing, copying, moving, renaming, deleting and listing files
  * Support for locking files
  * File matching functionality
  * A design that is consistent with FTP Connector and SFTP Connector


## Representation of File Attributes
Mule 4 provides a message structure of a payload and attributes in which the data moves around, making that payload file content. The attributes provide an object that contains metadata on the payload and information such as the file’s name, path, size, and timestamps. For FTP Connector and SFTP Connector, these attributes are named _file attributes_.
The Mule message specifies the encoding and MIME type, which describe the format in which a payload is represented. The file attributes describe a file’s encoding and MIME type.
## Before You Begin
To use this connector, you must be familiar with:
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to Anypoint Platform and Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * File Connector Reference
  * MuleSoft Help Center
Database Connector 1.9 | MuleSoft Documentation
# Database Connector 1.9
Anypoint Connector for Database (Database Connector) establishes communication between your Mule app and a relational database. Database Connector can connect to almost any Java Database Connectivity (JDBC) relational database and run SQL operations. An application can support multi-tenant scenarios using the same configuration element, changing the connection attributes based on, for example, information coming from each request.
Database Connector has connection providers that automatically set the driver class name and create JDBC URLs with given parameters for the following databases:
  * Derby
  * Microsoft SQL Server
  * MySQL
  * Oracle


You can set up other JDBC databases using a generic JDBC configuration. Database Connector is JDBC compliant. Ensure that for the connection configuration, you use a driver that is compliant with JDBC to avoid compatibility issues. Additionally, you can reference a JDBC `DataSource` object or an `XADataSource` object, which is required for XA transactions, by creating the object in Anypoint Studio using Spring.
## Before You Begin
To use this connector, you must be familiar with:
  * Anypoint Connectors
  * Mule runtime engine (Mule)
  * Elements and global elements in a Mule flow
  * Creating a Mule app using Anypoint Studio (Studio)


Before creating an app, you must have access to the database target resource, Anypoint Platform, and have downloaded the proper database driver for your database.
## Common Use Cases for the Connector
Database Connector enables you to:
  * Perform predefined queries, dynamically constructed queries, and template queries that are self-sufficient and customizable.
  * Specify DataWeave expressions in connector fields and configure attributes dynamically, depending on the database configuration you use.
  * Use a source listener operation to read from a database in the data source section of a flow.
  * Execute other operations to read and write to a database anywhere in the process section.
  * Perform multiple SQL requests in a single bulk update.
  * Make Data Definition Language (DDL) requests that alter the data structure rather than the data itself.
  * Execute stored procedures and SQL scripts.


For examples, see Examples.
## Audience
  * New users, read:
    * Using Anypoint Studio to Configure the Connector to create your Mule app
    * Examples, which provide one or more use cases for the connector
  * Advanced users, read:
    * XML and Maven Support
    * Examples, which provide one or more use cases for the connector


## Using Exchange Templates and Examples
Anypoint Exchange provides templates that you can use as starting points for your apps and examples that illustrate a complete solution.
  * Database Connector Examples
  * Database Connector Templates


## Next Step
After you complete the prerequisites and try the templates and examples, you are ready to create your own app and configure the connector using Anypoint Studio.
## See Also
  * Introduction to Anypoint Connectors
  * Use Exchange to Discover Connectors, Templates, and Examples
  * MuleSoft Help Center
Output a Field When Present | MuleSoft Documentation
# Output a Field When Present
This DataWeave example outputs a field if it is present in the input, a JSON array. The first object in the array contains `"insurance"`, while the second does not. The XML output mirrors this structure.
The example uses these functions:
  * `map` to go through every element within the input array.
  * `if($.insurance?)` to determine when to output an `insurance` field.


DataWeave Script:
```
%dw 2.0
output application/xml
---
users: { (payload map
    user: {
     name: $.name,
     (insurance: $.insurance) if($.insurance?)
    } )
}
```

Input JSON Payload:
```
[
 {
  "name" : "Julian",
  "gender" : "Male",
  "age" : 41,
  "insurance": "Osde"
 },
 {
  "name" : "Mariano",
  "gender" : "Male",
  "age" : 33
 }
]
```

Output XML:
```
<?xml version='1.0' encoding='US-ASCII'?>
<users>
 <user>
  <name>Julian</name>
  <insurance>Osde</insurance>
 </user>
 <user>
  <name>Mariano</name>
 </user>
</users>
```

## Related Examples
  * Map Data with DataWeave
  * Exclude Fields from the Output
  * Insert an Attribute into an XML Tag
  * Conditionally Reduce a List through a Function
  * Change Format According to Type


## See Also
  *   * DataWeave Selectors
  *
Gateway Policies in API Manager | MuleSoft Documentation
# Gateway Policies in API Manager
From API Manager, you can apply policies to APIs in Flex Gateway Connected Mode, Mule Gateway, or Anypoint Service Mesh.
Policies enable you to enforce regulations to help manage security, control traffic, and improve adaptability of your APIs. For example, a policy can control authentication, access, allotted consumption, and service level access (SLA). You can implement these regulations with no modification to the code implementation.
To find the policies available for your gateway, see Availability by Gateway.
For more information about specific policies and how to apply them, see:
  * Securing Flex Gateway APIs with Policies
  * Mule Gateway Policies Overview
Define Input and Output Structure of a Transformation (Design Center) | MuleSoft Documentation
# Define Input and Output Structure of a Transformation (Design Center)
To use the graphical view and construct mappings via drag and drop, the Transform component first needs information about what fields are available for dragging and dropping.
If you plan to create your transformation entirely by writing DataWeave source code, you can skip defining input and output and reference elements directly via code.
## Define Data Structure on Other Components
  1. Make sure that all other elements in the flow are fully configured.
When all other elements are configured and you have a component that has a predicted data structure, the structure can be passed onto the Transform component.
  2. Manually define input and output data structures if Design Center cannot predict the data structure.
For example, an HTTP Listener might receive requests containing any type of payload. If you know what this payload will look like, you can set the data type through the Input and Output tabs in the HTTP Listener dialog box.


## Define Data Structures in the Transform Component
  1. Click Set Data Type:
     * For the input pane, highlight the payload, attributes, or a variable and click the Set Data Type icon at the bottom of the input pane.
     * For the output pane, select the Set data type button. If the output pane has an existing data type, click the drop-down arrow at the top of the Output pane to set a new data type.
  2. Manually define the data structure by providing a sample or a schema.


## See Also
DataWeave Language
isInteger | MuleSoft Documentation
# isInteger
## isInteger(number: Number): Boolean
Returns `true` if the given number is an integer (which lacks decimals), `false` if not.
### Parameters
Name | Description  
---|---  
The number to evaluate.  
### Example
This example indicates whether the input is an integer for different values. Note numbers within strings get coerced to numbers.
#### Source
```
%dw 2.0
output application/json
---
[isInteger(1), isInteger(2.0), isInteger(2.2), isInteger("1")]
```

#### Output
```
[ true, true, false, true ]
```
Configuring Anypoint Platform PCE | MuleSoft Documentation
# Configuring Anypoint Platform PCE
After you complete the Anypoint Platform Private Cloud Edition (Anypoint Platform PCE) installation, review the following task to deploy and manage applications, register APIs, and use API Exchange on an Anypoint Platform PCE environment running on your own local network.
  * Deleting the Local User after Installing Anypoint Platform PCE
  * Configuring an External Identity Provider in Anypoint Platform PCE
  * Configuring SMTP in Anypoint Platform PCE
  * Configuring DNS in Anypoint Platform PCE
  * Configuring Security in Anypoint Platform PCE
  * Configuring a Disclaimer in Anypoint Platform PCE


## See Also
  * About Servers, Server Groups, and Clusters
  * Uploading Custom Policies
  *
Checks | MuleSoft Documentation
# Checks
Checks are different types of validations that you can add as action steps of an automation project.
  * This action step enables you to check if a process is running or not and either kill it or launch another program.
  * This action step searches for a user-defined image, waits until it appears or disappears, and can also be used as a relative anchor point for mouse clicks.
  * This action step takes a screenshot and saves it to the trace folder. You can use it to get feedback on what is happening at any point in a Workflow.
  * The Search Pattern action step searches for one or more patterns within a defined Search Area on the screen.
  * The action step Window Wait pauses the Workflow until a certain window is displayed or not displayed.