App Connect Designer Authoring reference

Use this reference to create, update, or delete App Connect Designer instances by using the IBM® Cloud Pak Platform UI, the Red Hat® OpenShift® web console or CLI, or the CLI for a Kubernetes environment.

Tip: A deployed IBM Cloud Pak for Integration Platform UI instance gives you access to the IBM Cloud Pak Platform UI, where you can create and manage instances of capabilities from a central location.

Introduction
Prerequisites
Red Hat OpenShift SecurityContextConstraints requirements
Resources required
Storage
Data encryption
Creating an instance
Updating the custom resource settings for an instance
Deleting an instance
Validation for custom resource values
Custom resource values
Supported platforms

Introduction

The App Connect Designer Authoring API enables you to create an App Connect Designer instance for developing, testing, and sharing integration flows. An App Connect Designer instance provides an authoring environment for hosting non-production workloads.

Usage guidelines:

Multiple instances of App Connect Designer can be created in a namespace (project) for individual or team use. Users in this namespace can then use their allocated instance to develop and manage flows.

Prerequisites

If using Red Hat OpenShift, Red Hat OpenShift Container Platform 4.12, 4.14, 4.15, 4.16, or 4.17 is required.
Note: For information about the custom resource (or operand) versions that are supported for each Red Hat OpenShift version, see spec.version values.
If using a Kubernetes environment, Kubernetes 1.28.x, 1.29.x, or 1.30.x is required. For more information, see Minimum requirements.
The IBM App Connect Operator must be installed in your cluster either through an independent deployment or an installation of IBM Cloud Pak for Integration. For further details, see the following information:
Ensure that you have cluster administrator authority or have been granted the appropriate role-based access control (RBAC).
If you want to use the command-line interface (CLI) to log in to your cluster and run commands to create and manage your IBM App Connect instances and other resources, ensure that the required CLI tools are installed on your computer. For more information, see Installing tools for managing the cluster, containers, and other resources (on Red Hat OpenShift), or Installing tools for managing the cluster, containers, and other resources (on Kubernetes).
You must have a Kubernetes pull secret called ibm-entitlement-key in the namespace before creating the instance. For more information, see Obtaining and applying your IBM Entitled Registry entitlement key.

Red Hat OpenShift SecurityContextConstraints requirements

IBM App Connect runs under the default restricted SecurityContextConstraints.

Resources required

Minimum recommended requirements:

CPU: 1.85 Cores
Memory: 2.6 GB
Storage: 10 GB

With Mapping Assist:

CPU: 3.1 Cores
Memory: 3.8 GB

For information about how to configure these values, see Custom resource values.

Storage

App Connect Designer requires separate storage volumes for Apache CouchDB and the artificial intelligence (AI) model that is implemented for the Mapping Assist incremental learning feature.

Supported storage types for Apache CouchDB
Supported storage types for the AI model

Supported storage types for Apache CouchDB

The IBM App Connect Operator provides a CouchDB NOSQL database server to store flow definition artifacts within a volume in the container’s file system.

Before you create the App Connect Designer instance, you must decide what type of storage to use for CouchDB because you will need to specify this storage type while creating the instance and will not be able to change this setting after the instance is created.

The following storage types can be used to allocate storage for CouchDB:

Persistent storage

Persistent storage is recommended for extra resilience because the CouchDB database is retained when pods restart.

Note: When you delete a 12.0.8.0-r1 or earlier Designer instance, the CouchDB database is automatically deleted. However, when you delete a 12.0.8.0-r2 or later Designer instance, the CouchDB database is retained and needs to be manually deleted. From the Red Hat OpenShift web console, you can delete the CouchDB database by navigating to Storage > PersistentVolumeClaims and then deleting the PVC that is named in the format data-c-designerName-m-0. From the Red Hat OpenShift or Kubernetes CLI, you can delete the CouchDB database by running one of these commands:

oc delete pvc pvcName -n namespaceName

kubectl delete pvc pvcName -n namespaceName

A persistent volume must be dynamically provisioned through a storage class that is available on the cluster by using the spec.couchdb.storage.class parameter. Storage classes must support the following modes:

Dynamic volume provisioning
ReadWriteOnce (RWO) access modes
volumeBindingMode: WaitForFirstConsumer (zone-local storage)
POSIX filesystem compatibility (for example, not NFS)

The mode requirements map to the following preferred options for common public cloud environments:

Provider	Type	Storage class	Documentation
IBM Cloud	IBM Block Storage	ibm-block-*	Documentation
AWS	Elastic Block Storage	aws-ebs	Documentation
Azure	Azure Disk	default or managed-premium	Documentation

For Google Compute Engine (GCE), Persistent Disk can be used, but a storage class must be manually created to support dynamic provisioning.

For more information about persistent volumes, see Persistent Volumes in the Kubernetes documentation.

If you choose persistent storage, you will need to specify a storage class, storage size, and number of replica pods.

Ephemeral storage

With this storage type, an ephemeral volume is created to store the CouchDB database when a Designer pod is started. The ephemeral (emptyDir) volume exists only for the lifetime of the pod, so the CouchDB database will be lost when the pod restarts. You might typically choose this storage type if creating an environment for demonstration or testing.

To define the storage type for CouchDB when creating an App Connect Designer instance, you must specify your preferred type in the custom resource settings by setting the spec.couchdb.storage.type parameter and then complete the other spec.couchdb.storage.* parameters as appropriate for the selected storage type.

Supported storage types for the AI model

When you create an App Connect Designer instance, you can optionally choose to enable the incremental learning feature, which uses AI modeling techniques to improve the accuracy of source-to-target mapping suggestions that are offered in all authored flows. A supplied AI model is retrained at periodic intervals with training data that is collected about your mapping preferences.

Before you create the App Connect Designer instance, you must decide what type of storage to use for the AI model because you will need to specify this storage type and any associated settings while creating the instance.

Note: Incremental learning is available only if the spec.version value in the App Connect Designer custom resource resolves to 12.0.1.0-r1 or later. For more information about incremental learning, see Simplifying data mapping and data transformation with AI-powered suggestions.

The following storage types can be used to allocate storage for the AI model:

Persistent storage

With this storage type, the AI model is stored in a persistent volume in the container’s file system. The persistent volume can be dynamically provisioned through a storage class that is available on the cluster, or can be requested through a claim name. With persistent storage, the AI model is retained in the file system when pods restart and is deleted only when you delete the App Connect Designer instance.

Note: Persistent storage is applicable only if the spec.version value in the App Connect Designer custom resource resolves to 12.0.1.0-r1 or later.

Incremental learning requires a storage class with ReadWriteMany (RWX) capability. If using IBM Cloud, use the ibmc-file-gold-gid storage class.

If you choose persistent storage, you will need to specify a storage class or the name of an existing claim. (A storage size does not need to be manually specified because the allocated default is suitable for requirements.)

Simple Storage Service (S3) storage

S3 storage offers an alternative option to persistent storage, and supports the use of an object storage service for storing the AI model by using the S3 REST API.

Note: S3 storage is applicable only if the spec.version value in the App Connect Designer custom resource resolves to 12.0.1.0-r4 or later.

Restriction:

S3 storage is not supported when the IBM App Connect Operator is installed in a restricted network because a cluster requires internet access to read and write training data from or to an S3 object store.
Only Amazon S3 and IBM Cloud Object Storage S3 are supported as S3 providers.

The AI model will be stored as an object with read/write access in a specified bucket in your S3 instance and can be viewed in the S3 bucket. The AI model is stored in ZIP format in the following location in the bucket, and the ZIP object will be overwritten (with the same name) each time the model is retrained:

/mapping-assist-model/mapping_assist_v1.1.0.zip

Warning: Do not delete an AI model from the S3 bucket if that model is in use by a Designer instance because the accumulated data will be lost. Although a new base model will automatically be created for the Designer instance, this model will need to undergo training at the next scheduled interval (using data collated only during that interval) before being added to the S3 bucket.

If you choose S3 storage, you will need to specify the following storage settings for your provisioned S3 instance:

The name of an existing bucket for storing the AI model
You are not restricted from using an S3 bucket that already contains other objects because the AI model is separately stored in a dedicated folder (mapping-assist-model). If you want to enable S3 storage for AI models in multiple App Connect Designer instances, you must use a separate S3 bucket for each instance to ensure that the AI model for one instance does not get overwritten by the AI model for another instance.
An S3 endpoint to which the S3 REST API sends requests for reading and writing objects
You should be able to locate the available endpoints from your S3 instance. For example, on IBM Cloud Object Storage S3, you can locate the endpoints from the Endpoints page.

To minimize latency, it is recommended that you use an S3 bucket that is in the same geographic area as your App Connect Designer instance. Also use an endpoint with a location or region that is similar to where Designer is deployed. For more information, see Endpoints and storage locations in the IBM Cloud Object Storage S3 documentation and Amazon Simple Storage Service endpoints and quotas in the Amazon Web Services documentation.
S3 credentials for connecting to the bucket
You will need to supply these credentials by creating a configuration of type S3Credentials. For more information, see Creating a configuration of type S3Credentials for use with App Connect Designer.

To define the storage type for the AI model when creating an App Connect Designer instance, you must specify your preferred type in the custom resource settings by setting the spec.designerMappingAssist.incrementalLearning.storage.type parameter and then complete the other spec.designerMappingAssist.incrementalLearning.storage.* parameters as appropriate for the selected storage type. If you want to create a Designer instance that uses S3 storage for the AI model, your must first create a configuration object of type S3Credentials to store the credentials for accessing the bucket.

Data encryption

To secure data that is stored at rest, the following options are supported for enabling data encryption:

Portworx Enterprise
For more information, see Step 4: Set up volume encryption with IBM Key Protect.
IBM Cloud File Storage
For more information, see Setting up encryption for Block Storage for VPC.
Amazon services

Other options, such as Network File System (NFS), are not supported.

Creating an instance

You can create an App Connect Designer instance from the IBM Cloud Pak Platform UI, the Red Hat OpenShift web console or CLI, or the CLI for a Kubernetes environment.

Configuring identity and access management (IAM):

For App Connect Designer 12.0.10.0-r2 or later instances that you create by using IBM App Connect Operator 11.0.0 or later, you can use IAM to control access to a Designer instance. IAM is implemented by using Keycloak to authenticate users and to authorize access. For information about the prerequisites for IAM, enabling IAM for a Designer instance, and configuring Keycloak, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.

Before you begin

Ensure that the Prerequisites are met.
If you want to create an App Connect Designer instance that uses S3 storage for the AI model, ensure that you have created a configuration object of type S3Credentials as described in Creating a configuration of type S3Credentials for use with App Connect Designer.
Decide how to control upgrades to the instance when a new version becomes available. The spec.version value that you specify while creating the instance will determine how that instance is upgraded after installation, and whether you will need to specify a different license or version number for the upgrade. To help you decide whether to specify a spec.version value that either lets you subscribe to a channel for updates, or that uses a specific version for the instance, review the Upgrade considerations for channels, versions, and licenses before you start this task.

Namespace restriction for an instance, server, configuration, or trace:
The namespace in which you create an instance or object must be no more than 40 characters in length.

Create options:

Creating an instance from the IBM Cloud Pak Platform UI
Creating an instance from the Red Hat OpenShift web console
Creating an instance from the Red Hat OpenShift CLI or Kubernetes CLI

Creating an instance from the IBM Cloud Pak Platform UI

To create an App Connect Designer instance from the IBM Cloud Pak Platform UI, complete the following steps:

From a browser window, log in to the Platform UI.
Tip: You can use the generated URL for a deployed IBM Cloud Pak for Integration Platform UI instance to access the Platform UI.
- Applicable to IBM App Connect Operator 11.0.0 or later: The Platform UI Instances page opens as the home page. The welcome banner includes a theme switcher that you can use to choose a light theme, a dark theme, or a custom theme that matches your existing system UI.
- Applicable to IBM App Connect Operator 10.1.1 or earlier: The Platform UI home page opens with cards and navigation menu options that provide access to the instances and other resources that you are authorized to create, manage, or use. For information about completing administration tasks (such as user management or platform customization) from this page, see Platform UI in the IBM Cloud Pak foundational services documentation.
  
  From the navigation menu , expand Administration and click Integration instances.
From the Instances (or Integration instances) page, click Create an instance.
To create an App Connect Designer instance from the Create an instance page, click the Integration design tile and click Next.
From the Create an integration design instance page, click a tile to select which type of instance you want to create:
- Quick start with AI enabled: Deploy an App Connect Designer instance with one replica pod, and with AI-powered mapping assist and transformation generation enabled.
  Consider choosing this option if you are the sole user or if you want to quickly get started for evaluative purposes, and additionally want to try out these features:
  - Mapping assist, which provides "smart mapping" that enables you to auto-populate the fields within a flow with the best possible matches from previous nodes
  - Transformation generation, which uses supplied sample data or drop-down list values to construct complex (JSONata) transformations that let you easily map source data to target data
- Development with AI enabled: Deploy an App Connect Designer instance with multiple replica pods for resilience and high availability, and with AI-powered mapping assist and transformation generation enabled.
  Consider choosing this option to create a Development deployment that additionally provides the following features:
  - Mapping assist, which provides "smart mapping" that enables you to auto-populate the fields within a flow with the best possible matches from previous nodes
  - Transformation generation, which uses supplied sample data or drop-down list values to construct complex (JSONata) transformations that let you easily map source data to target data
- Quick start: Deploy an App Connect Designer instance with one replica pod.
  Consider choosing this option if you are the sole user and want to quickly get started for evaluative purposes. AI-powered mapping assist and transformation generation are disabled by default.
- Development: Deploy an App Connect Designer instance with multiple replica pods for resilience and high availability.
  Consider choosing this option for a multi-user environment with larger workloads than the Quick start deployment, with the capability to switch between replica pods to support failover. AI-powered mapping assist and transformation generation are disabled by default.
- Select a template from Automation assets: (Applicable to IBM App Connect Operator 11.0.0 or later) Create a Designer instance by selecting an existing template from Automation assets. For more information, see Deploying an instance from a template in the IBM Cloud Pak for Integration documentation.
Click Next. A UI form view opens with the minimum configuration that is required to create the instance.
Complete either of the following steps:
- To quickly get going, complete the standard set of configuration fields. You can display advanced settings in the UI form view by setting Advanced settings to on. Note that some fields might not be represented in the form.
  Note: Identity and access management (IAM) by using Keycloak is enabled by default although the authentication and authorization fields (which are used to enable or disable IAM) are not displayed in UI form view. For more information about using IAM with the instance that you are creating, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
  - Name: Enter a short distinctive name that uniquely identifies this Designer instance.
  - Namespace: Enter the name of the namespace (project) where you want to create the Designer instance. If the Platform UI is deployed in a single namespace (namespace-scoped), this namespace is displayed and cannot be changed.
  - Labels: (Applicable to IBM App Connect Operator 11.0.0 or later) Add one or more labels as key/value pairs, which can be used to organize and categorize (scope and select) instances. For more information, see Labels and Selectors.
    By default, a label is provided with a key of backup.appconnect.ibm.com/component and a value of designerauthoring. This label is used if you need to run backup and restore operations by using OpenShift API for Data Protection (OADP) and is ignored otherwise.
  - Channel or version: Select an App Connect product (fix pack) version that the Designer instance is based on. You can select a channel that will resolve to the latest fully qualified version on that channel, or select a specific fully qualified version. If you are using IBM App Connect Operator 7.1.0 or later, the supported channels or versions will depend on the Red Hat OpenShift version that is installed in your cluster. For more information about these values, see spec.version values.
  - Accept: Review the license in the supplied link and then click this check box to accept the terms and conditions.
  - License LI: Select a license identifier that aligns with the channel or the fully qualified version that you selected. For more information, see Licensing reference for IBM App Connect Operator.
  - License use: Select an appropriate CloudPakForIntegration or AppConnectEnterprise license type that you are entitled to use.
    IAM entitlements:
    - If you purchased Cloud Pak for Integration, you are entitled to use either CloudPakForIntegration* or AppConnectEnterprise* style licenses. However, to use a CloudPakForIntegration* license, a Platform UI instance must be deployed.
    - If you purchased the IBM App Connect Operator for an independent deployment, you are restricted to AppConnectEnterprise* style licenses regardless of whether IAM is enabled or disabled. (Although installation of the Cloud Pak for Integration and other Operators is permitted for configuring IAM, you are not allowed to deploy the Platform UI.)
  - Replicas: Specify the number of replica pods to run for this deployment.
  - Enable Mapping Assist: Set this switch to on to enable the Mapping Assist components.
    Consider whether you want to enable Mapping Assist for smart mapping and data transformation (which requires extra resources). You can also optionally enable Mapping Assist incremental learning to use AI modeling for enhanced smart mapping. If you enable incremental learning, you'll need to specify a "learning" frequency, and indicate whether the AI model should be stored in a persistent volume or an S3 bucket. If you are using an S3 bucket, you'll need to provide details for connecting to this bucket, including the name of the configuration object of type S3Credentials, which you created to store your S3 credentials. In YAML view, you can use the spec.designerMappingAssist.enabled and spec.designerMappingAssist.incrementalLearning.* parameters to configure the Mapping Assist features. For more information about Mapping Assist and the configuration object for S3 storage, see Simplifying data mapping and data transformation with AI-powered suggestions and Creating a configuration of type S3Credentials for use with App Connect Designer.
  - Storage type: Select the type of storage to use for CouchDB.
    - persistent-claim: Choose this option for storage in a persistent volume in the container’s file system. Retains the existing configuration, logs, and persistent messages when pods restart.
    - ephemeral: Choose this option for storage in an ephemeral volume that exists only for the lifetime of the pod.
  - Storage class: Select a supported storage class for your cluster, which should be used to dynamically provision a persistent volume that belongs to that class. This value is required if Storage type is set to persistent-claim.
    IAM requirement: Keycloak requires block storage and a storage class that is set as the default class. For more information, see Storage options for Keycloak in the IBM Cloud Pak for Integration documentation.
  - Size: Specify the maximum amount of storage required for a persistent volume for CouchDB in decimal or binary format; that is, Gi or G. This value is required if Storage type is set to persistent-claim.
  Set Advanced settings to on if you want to specify any advanced settings from the UI form view.
  - Advanced: Log Level: Select the level of information to display in the CouchDB logs. Valid values are info, warning, error, debug, and notice.
  - Advanced: Replicas: Specify the number of CouchDB replica pods to run between 1-10.
  - Advanced: Secret to use for pulling images: Specify an optional list of references to secrets in the same namespace to use for pulling any of the images used. If specified, these secrets are passed to individual puller implementations for them to use. For example, in the case of Docker, only DockerConfig type secrets are honored. For more information, see https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod.
  - Runtime Container Image name & tag: Specify the path to the Docker image for the runtime container.
  - Runtime Container ImagePullPolicy: Indicate whether you want images for the runtime container to be pulled every time, never, or only if they are not present. Valid values are Always, Never, and IfNotPresent.
  - Runtime Container (Resource requirements): Specify resource requirements for running the runtime container. For information about the values that you can specify, see the spec.integrationServer.containers.runtime.resources.* parameters in Custom resource values.
- For a more advanced configuration, click YAML to switch to the YAML view and then update the editor with your required parameters.
  - For information about the available parameters and their values, see Custom resource values.
    In the default parameters that are presented, be aware that a value is required for spec.couchdb.storage.class (and for spec.couchdb.storage.size) when spec.couchdb.storage.type is set to persistent-claim. The spec.couchdb.storage.class value must match a supported storage class for your cluster. (The UI form view presents these classes in a drop-down list.)
```
spec:
  couchdb:
    storage:
      class: 'storageClassValue'
      size: 10Gi
      type: persistent-claim
```
Click Create. You are redirected to the Instances (or Integration instances) page. An entry for the instance is shown in the table with an initial status of Pending, which you can click to check the progress of the deployment. When the deployment completes, the status changes to Ready.

What to do next

If IAM with Keycloak is enabled for this instance, use the Keycloak Admin Console to manage user access to the instance by setting up users with assigned roles. For more information, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
Share the URL of the Platform UI with the configured users and supply the authentication credentials that they can use to log in to the Platform UI and Designer instance.
The authorized users can access the Designer (Integration design) instance by clicking the name in the Platform UI, and then use the instance to author flows.

Creating an instance from the Red Hat OpenShift web console

To create an App Connect Designer instance by using the Red Hat OpenShift web console, complete the following steps:

From a browser window, log in to the Red Hat OpenShift Container Platform web console. Ensure that you are in the Administrator perspective .
From the navigation, click Operators > Installed Operators.
If required, select the namespace (project) in which you installed the IBM App Connect Operator.
From the Installed Operators page, click IBM App Connect.
From the Operator details page for the App Connect Operator, click the Designer Authoring tab. Any previously created Designer instances are displayed in a table.
Click Create DesignerAuthoring.
From the Details tab on the Operator details page, you can also locate the Designer Authoring tile and click Create instance to specify installation settings for the instance.
To use the Form view, ensure that Form view is selected and then complete the fields. Note that some fields might not be represented in the form.
- Name: Enter a short distinctive name that uniquely identifies this Designer instance.
- Labels: (Applicable to IBM App Connect Operator 11.0.0 or later)
  By default, a label is provided with a key of backup.appconnect.ibm.com/component and a value of designerauthoring. This label is used if you need to run backup and restore operations by using OpenShift API for Data Protection (OADP) and is ignored otherwise. For more information, see Backing up and restoring your IBM App Connect resources and persistent volumes on Red Hat OpenShift.
- License/Accept: Select this checkbox to accept the terms and conditions of the license.
- License/License LI: Select a license identifier that aligns with the channel or the fully qualified version that you selected. For more information, see Licensing reference for IBM App Connect Operator.
- License/License use: Select an appropriate CloudPakForIntegration or AppConnectEnterprise license type that you are entitled to use.
  IAM entitlements:
  - If you purchased Cloud Pak for Integration, you are entitled to use either CloudPakForIntegration* or AppConnectEnterprise* style licenses. However, to use a CloudPakForIntegration* license, a Platform UI instance must be deployed.
  - If you purchased the IBM App Connect Operator for an independent deployment, you are restricted to AppConnectEnterprise* style licenses regardless of whether IAM is enabled or disabled. (Although installation of the Cloud Pak for Integration and other Operators is permitted for configuring IAM, you are not allowed to deploy the Platform UI.)
- Couch DB/storage/Storage type: Select the type of storage to use for CouchDB.
  - persistent-claim: Choose this option for storage in a persistent volume in the container’s file system. Retains the existing configuration, logs, and persistent messages when pods restart.
  - ephemeral: Choose this option for storage in an ephemeral volume that exists only for the lifetime of the pod.
- Couch DB/storage/Storage class: Select a supported storage class for your cluster, which should be used to dynamically provision a persistent volume that belongs to that class. This value is required if Storage type is set to persistent-claim.
  IAM requirement: Keycloak requires block storage and a storage class that is set as the default class. For more information, see Storage options for Keycloak in the IBM Cloud Pak for Integration documentation.
- Couch DB/storage/Log Level: Select the level of information to display in the CouchDB logs. Valid values are info, warning, error, debug, and notice.
- Couch DB/storage/Replicas: Specify the number of CouchDB replica pods to run between 1-10.
- Channel or version: Select an App Connect product (fix pack) version that the Designer instance is based on. You can select a channel that will resolve to the latest fully qualified version on that channel, or select a specific fully qualified version. If you are using IBM App Connect Operator 7.1.0 or later, the supported channels or versions will depend on the Red Hat OpenShift version that is installed in your cluster. For more information about these values, see spec.version values.
- Replicas: Specify the number of replica pods to run for this deployment.
- Designer Mapping Assist/Enable Mapping Assist: Set this switch to true to enable the Mapping Assist components.
  Consider whether you want to enable Mapping Assist for smart mapping and data transformation (which requires extra resources). You can also optionally enable Mapping Assist incremental learning to use AI modeling for enhanced smart mapping. If you enable incremental learning, you'll need to specify a "learning" frequency, and indicate whether the AI model should be stored in a persistent volume or an S3 bucket. If you are using an S3 bucket, you'll need to provide details for connecting to this bucket, including the name of the configuration object of type S3Credentials, which you created to store your S3 credentials. In YAML view, you can use the spec.designerMappingAssist.enabled and spec.designerMappingAssist.incrementalLearning.* parameters to configure the Mapping Assist features. For more information about Mapping Assist and the configuration object for S3 storage, see Simplifying data mapping and data transformation with AI-powered suggestions and Creating a configuration of type S3Credentials for use with App Connect Designer.
Expand the Advanced configuration section if you want to specify any advanced settings in Form view.
- Authentication and Authorization:
  - Authentication/integrationKeycloak/Enabled: Select this checkbox to control access to the Designer instance by using identity and access management (IAM) to validate user identities.
  - Authorization/integrationKeycloak/Enabled Select this checkbox to control access to the Designer instance by using IAM to grant access permissions.
  You must select both of these checkboxes to enable Keycloak, which implements IAM. Keycloak is enabled by default. For more information about using IAM with the instance that you are creating, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
  
  If you do not want to restrict access to the instance, you must clear both of the Enabled checkboxes. Also ensure that you are using an AppConnectEnterprise* style license.
  
  Restriction: These settings are not applicable for Kubernetes environments.
- Secret to use for pulling images: Specify an optional list of references to secrets in the same namespace to use for pulling any of the images used. If specified, these secrets are passed to individual puller implementations for them to use. For example, in the case of Docker, only DockerConfig type secrets are honored. For more information, see https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod.
- Integration Server Pod/containers:
  - Integration Server Pod/containers/runtime/Image name & tag: Specify the path to the Docker image for the runtime container.
  - Integration Server Pod/containers/runtime/ImagePullPolicy: Indicate whether you want images for the runtime container to be pulled every time, never, or only if they are not present. Valid values are Always, Never, and IfNotPresent.
  - Integration Server Pod/containers/runtime/Resource requirements: Specify resource requirements for running the runtime container. For information about the values that you can specify, see the spec.integrationServer.containers.runtime.resources.* parameters in Custom resource values.
  For information about the remaining values that you can specify, see the spec.integrationServer.containers.* parameters in Custom resource values.
- Pod/containers/container_name: Specify settings for running the Designer containers. For information about the values that you can specify, see the spec.pod.containers.* parameters in Custom resource values.
- Switch Server/Name: Specify the name of an existing switch server that enables secure connectivity when running callable flows in the Designer instance, or when running flows that interact with applications in a private network. The switch server name is the metadata.name value in the switch server custom resource. For information about how to create a switch server, see App Connect Switch Server reference.
  Note: If you want to create and run callable flows in the Designer instance or if you want to create flows that interact with applications in a private network, you must configure the Designer instance to use a switch server.
  - If a switch server is already deployed in the namespace, complete the Switch Server/Name field in Form view, or add the spec.switchServer.name parameter to the Designer YAML, where switchServerName is the metadata.name value in the switch server custom resource.
    spec: switchServer: name: switchServerName
    If the metadata.name value for the switch server is set to default, the Designer instance is automatically configured to use the switch server even if spec.switchServer.name is not explicitly specified. For example:
```
apiVersion: appconnect.ibm.com/v1beta1
kind: SwitchServer
metadata:
  name: default
...
```
  - If a switch server is not yet deployed in the namespace, you can create a switch server after you create the Designer instance. Then, update the Designer custom resource to add the spec.switchServer.name setting as described in Updating the custom resource settings for an instance. (If the metadata.name value for the switch server is set to default, you do not need to explicitly add the spec.switchServer.name setting.)
    For information about how to create a switch server, see App Connect Switch Server reference.
  A Designer instance that is configured to use a switch server includes a Callable flows page and a Private network connections page that you can use to configure connectivity to callable flows and to applications in a private network.
Optional: For a finer level of control over your installation settings, click YAML view to switch to the YAML view. Update the content of the YAML editor with the parameters and values that you require for this Designer instance.
To view the full set of parameters and values available, see Custom resource values.
Click Create to start the deployment. An entry for the Designer instance is shown in the DesignerAuthorings table, initially with a Pending status.
Click the Designer instance name to view information about its definition and current status.
On the Details tab of the page, you can view the following information:
- The Conditions section reveals the progress of the deployment.
- If you created the Designer instance by using IBM App Connect Operator 11.2.0 or later, the Designer UI field provides the URL for accessing the Designer instance. If Keycloak is enabled, the Keycloak UI field also provides the URL of the Keycloak instance that you can use to access the Keycloak Admin Console. (These URLs are displayed after the deployment completes.) You can also locate these URLs under Networking > Routes in the console navigation.
- If you created the Designer instance by using IBM App Connect Operator 11.1.0 or earlier, the UI URL field provides the URL for accessing the Designer instance. (This URL is displayed after the deployment completes.) You can also locate this URL under Networking > Routes in the console navigation.
You can use the breadcrumb trail to return to the (previous) Operator details page for the App Connect Operator. When the deployment is complete, the status is shown as Ready in the DesignerAuthorings table.

What to do next

If IAM with Keycloak is enabled for this instance, use the Keycloak Admin Console to manage user access to the instance by setting up users with assigned roles. For more information, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
Share the Designer UI (or UI URL) URL with the users who need to access the Designer instance. If IAM is enabled, also supply the authentication credentials that users can use to log in to the instance.
Users can then access and use the Designer instance to author flows.

Creating an instance from the Red Hat OpenShift CLI or Kubernetes CLI

To create an App Connect Designer instance from the Red Hat OpenShift CLI, complete the following steps.

Note: These instructions relate to the Red Hat OpenShift CLI, but can be applied to a Kubernetes environment by using the relevant command to log in to the cluster, and substituting oc with kubectl where appropriate.

From your local computer, create a YAML file that contains the configuration for the App Connect Designer instance that you want to create. Include the metadata.namespace parameter to identify the namespace in which you want to create the instance; this should be the same namespace where the other App Connect instances or resources are created.
- To view the full set of parameters and values that you can specify, see Custom resource values.
  In the default parameters that are presented, be aware that a value is required for spec.couchdb.storage.class (and for spec.couchdb.storage.size) when spec.couchdb.storage.type is set to persistent-claim. The spec.couchdb.storage.class value must match a supported storage class for your cluster.
```
spec:
  couchdb:
    storage:
      class: 'storageClassValue'
      size: 10Gi
      type: persistent-claim
```
  IAM requirement: Keycloak requires block storage and a storage class that is set as the default class. For more information, see Storage options for Keycloak in the IBM Cloud Pak for Integration documentation.
  Note: If you want to create and run callable flows in the Designer instance or if you want to create flows that interact with applications in a private network, you must configure the Designer instance to use a switch server.
  - If a switch server is already deployed in the namespace, complete the Switch Server/Name field in Form view, or add the spec.switchServer.name parameter to the Designer YAML, where switchServerName is the metadata.name value in the switch server custom resource.
    spec: switchServer: name: switchServerName
    If the metadata.name value for the switch server is set to default, the Designer instance is automatically configured to use the switch server even if spec.switchServer.name is not explicitly specified. For example:
```
apiVersion: appconnect.ibm.com/v1beta1
kind: SwitchServer
metadata:
  name: default
...
```
  - If a switch server is not yet deployed in the namespace, you can create a switch server after you create the Designer instance. Then, update the Designer custom resource to add the spec.switchServer.name setting as described in Updating the custom resource settings for an instance. (If the metadata.name value for the switch server is set to default, you do not need to explicitly add the spec.switchServer.name setting.)
    For information about how to create a switch server, see App Connect Switch Server reference.
  A Designer instance that is configured to use a switch server includes a Callable flows page and a Private network connections page that you can use to configure connectivity to callable flows and to applications in a private network.
  Consider whether you want to enable Mapping Assist for smart mapping and data transformation (which requires extra resources). You can also optionally enable Mapping Assist incremental learning to use AI modeling for enhanced smart mapping. If you enable incremental learning, you'll need to specify a "learning" frequency, and indicate whether the AI model should be stored in a persistent volume or an S3 bucket. If you are using an S3 bucket, you'll need to provide details for connecting to this bucket, including the name of the configuration object of type S3Credentials, which you created to store your S3 credentials. In YAML view, you can use the spec.designerMappingAssist.enabled and spec.designerMappingAssist.incrementalLearning.* parameters to configure the Mapping Assist features. For more information about Mapping Assist and the configuration object for S3 storage, see Simplifying data mapping and data transformation with AI-powered suggestions and Creating a configuration of type S3Credentials for use with App Connect Designer.
- To control access to the instance by using identity and access management (IAM), ensure that both of these parameters are set to true (the default).
  - spec.authentication.integrationKeycloak.enabled: This setting ensures that user identities can be validated.
  - spec.authorization.integrationKeycloak.enabled: This setting ensures that access permissions can be granted.
  This value enables Keycloak, which implements IAM. For more information about using IAM with the instance that you are creating, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
  
  If you do not want to restrict access to the instance, ensure that both of these parameters are set to false. Also ensure that you are using an AppConnectEnterprise* style license.
  
  Restriction: These settings are not applicable for Kubernetes environments.
- For licensing information, see Licensing reference for IBM App Connect Operator.
  IAM entitlements:
  - If you purchased Cloud Pak for Integration, you are entitled to use either CloudPakForIntegration* or AppConnectEnterprise* style licenses. However, to use a CloudPakForIntegration* license, a Platform UI instance must be deployed.
  - If you purchased the IBM App Connect Operator for an independent deployment, you are restricted to AppConnectEnterprise* style licenses regardless of whether IAM is enabled or disabled. (Although installation of the Cloud Pak for Integration and other Operators is permitted for configuring IAM, you are not allowed to deploy the Platform UI.)
The following examples (Example 1 and Example 2) show a Designer CR with settings to configure CouchDB storage, and configure an existing switch server for callable flow and private network connectivity. The settings also enable Mapping Assist and incremental learning with a persistent-claim storage definition for the AI model.
Example 1: Keycloak enabled for IAM by default
```
apiVersion: appconnect.ibm.com/v1beta1
kind: DesignerAuthoring
metadata:
  name: des-mapast
  labels:
    backup.appconnect.ibm.com/component: designerauthoring
  namespace: mynamespace
spec:
  license:
    accept: true
    license: L-XRNH-47FJAW
    use: CloudPakForIntegrationNonProduction
  couchdb:
    storage:
      size: 10Gi
      type: persistent-claim
      class: ocs-storagecluster-cephfs
    replicas: 1
  designerMappingAssist:
    incrementalLearning:
      storage:
        type: persistent-claim
        class: ocs-storagecluster-cephfs
      schedule: Every 15 days
      useIncrementalLearning: true
    enabled: true
  switchServer:
    name: default
  authentication:
    integrationKeycloak:
      enabled: true
  authorization:
    integrationKeycloak:
      enabled: true
  designerFlowsOperationMode: local
  replicas: 3
  version: '12.0'
```
Example 2: Keycloak disabled - IAM not required (or not supported on Kubernetes)
```
apiVersion: appconnect.ibm.com/v1beta1
kind: DesignerAuthoring
metadata:
  name: des-mapast
  labels:
    backup.appconnect.ibm.com/component: designerauthoring
  namespace: mynamespace
spec:
  license:
    accept: true
    license: L-XRNH-47FJAW
    use: AppConnectEnterpriseProduction
  couchdb:
    storage:
      size: 10Gi
      type: persistent-claim
      class: valid-storage-class
    replicas: 1
  designerMappingAssist:
    incrementalLearning:
      storage:
        type: persistent-claim
        class: valid-storage-class
      schedule: Every 15 days
      useIncrementalLearning: true
    enabled: true
  switchServer:
    name: default
  authentication:
    integrationKeycloak:
      enabled: false
  authorization:
    integrationKeycloak:
      enabled: false
  designerFlowsOperationMode: local
  replicas: 3
  version: '12.0'
```
The following examples (Example 3 and Example 4) show a Designer CR with settings to configure CouchDB storage, and configure an existing switch server for callable flow and private network connectivity. The settings also enable Mapping Assist and incremental learning with an s3 storage definition for the AI model.
Example 3: Keycloak enabled for IAM by default
```
apiVersion: appconnect.ibm.com/v1beta1
kind: DesignerAuthoring
metadata:
  name: des-mapast
  labels:
    backup.appconnect.ibm.com/component: designerauthoring
  namespace: mynamespace
spec:
  license:
    accept: true
    license: L-XRNH-47FJAW
    use: CloudPakForIntegrationNonProduction
  couchdb:
    storage:
      size: 10Gi
      type: persistent-claim
      class: ocs-storagecluster-cephfs
    replicas: 1
  designerMappingAssist:
    incrementalLearning:
      storage:
        type: s3
        bucket: appc-operator-e2e
        host: s3.eu-gb.cloud-object-storage.appdomain.cloud
        s3Configuration: s3credentials-ibmcosiam
      schedule: Every 15 days
      useIncrementalLearning: true
    enabled: true
  switchServer:
    name: default
  authentication:
    integrationKeycloak:
      enabled: true
  authorization:
    integrationKeycloak:
      enabled: true
  designerFlowsOperationMode: local
  replicas: 3
  version: '12.0'
```
Example 4: Keycloak disabled - IAM not required (or not supported on Kubernetes)
```
apiVersion: appconnect.ibm.com/v1beta1
kind: DesignerAuthoring
metadata:
  name: des-mapast
  labels:
    backup.appconnect.ibm.com/component: designerauthoring
  namespace: mynamespace
spec:
  license:
    accept: true
    license: L-XRNH-47FJAW
    use: AppConnectEnterpriseProduction
  couchdb:
    storage:
      size: 10Gi
      type: persistent-claim
      class: valid-storage-class
    replicas: 1
  designerMappingAssist:
    incrementalLearning:
      storage:
        type: s3
        bucket: appc-operator-e2e
        host: s3.eu-gb.cloud-object-storage.appdomain.cloud
        s3Configuration: s3credentials-ibmcosiam
      schedule: Every 15 days
      useIncrementalLearning: true
    enabled: true
  switchServer:
    name: default
  authentication:
    integrationKeycloak:
      enabled: false
  authorization:
    integrationKeycloak:
      enabled: false
  designerFlowsOperationMode: local
  replicas: 3
  version: '12.0'
```
Save this file with a .yaml extension; for example, designer_cr.yaml.
From the command line, log in to your Red Hat OpenShift cluster by using the oc login command.
Run the following command to create the App Connect Designer instance. (Use the name of the .yaml file that you created.)
```
oc apply -f designer_cr.yaml
```

Run the following command to check the status of the App Connect Designer instance and verify that it is ready:

oc get designerauthorings -n namespace

On IBM App Connect Operator 11.2.0 or later, the output also provides the URL of the Designer instance as shown in the following example. If Keycloak is enabled, the URL of the Keycloak instance, which you can use to access the Keycloak Admin Console, is also displayed.

NAME                     RESOLVEDVERSION   URL                                                                                 KEYCLOAKURL                                                                  CUSTOMIMAGES   STATUS   AGE
des-fd-keyclk-cp4ilic    12.0.12-r7      https://des-fd-keyclk-cp4ilic-ui-ace-fiona.apps.acecc-shared-1120-cd-414-abc.com    https://keycloak-ibm-common-services.apps.acecc-shared-1120-cd-414-abc.com   false          Ready    3h11m

On IBM App Connect Operator 11.1.0 or earlier, the output also provides the URL of the Designer instance; for example:

NAME         RESOLVEDVERSION   REPLICAS   CUSTOMIMAGES   STATUS    URL                                                                        AGE
des-mapast   12.0.10.0-r3      3          false          Ready     https://des-mapast-designer-https-mynamespace.apps.acecc-abcde.icp4i.com   50m12s

What to do next

If IAM with Keycloak is enabled for this instance on Red Hat OpenShift, use the Keycloak Admin Console to manage user access to the instance by setting up users with assigned roles. For more information, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.
Share the URL value in the output with the users who need to access the Designer instance. If IAM is enabled, also supply the authentication credentials that users can use to log in to the instance.
Users can then access and use the Designer instance to author flows.

Note: If you are using a Kubernetes environment, ensure that you create an ingress definition after you create this instance, to make its internal service publicly available. For more information, see Creating ingress definitions for external access to your IBM App Connect instances.

Updating the custom resource settings for an instance

If you want to change the settings of an existing App Connect Designer instance, you can edit its custom resource settings from the IBM Cloud Pak Platform UI, the Red Hat OpenShift web console or CLI, or the CLI for a Kubernetes environment. For example, you might want to enable Mapping Assist if currently disabled, or configure the instance to use a switch server for callable flows or a private network connection.

Restriction: You cannot update standard settings such as the kind of resource (kind), and the name and namespace (metadata.name and metadata.namespace), as well as some system-generated settings, or settings such as the storage type of certain components. An error message will be displayed when you try to save.

Ensure that you have cluster administrator authority or have been granted the appropriate role-based access control (RBAC).

Update options:

Updating an instance from the IBM Cloud Pak Platform UI
Updating an instance from the Red Hat OpenShift web console
Updating an instance from the Red Hat OpenShift CLI or Kubernetes CLI

Updating an instance from the IBM Cloud Pak Platform UI

To update an App Connect Designer instance from the IBM Cloud Pak Platform UI, complete the following steps:

From a browser window, log in to the Platform UI.
Tip: You can use the generated URL for a deployed IBM Cloud Pak for Integration Platform UI instance to access the Platform UI.
- Applicable to IBM App Connect Operator 11.0.0 or later: The Platform UI Instances page opens as the home page. The welcome banner includes a theme switcher that you can use to choose a light theme, a dark theme, or a custom theme that matches your existing system UI.
- Applicable to IBM App Connect Operator 10.1.1 or earlier: The Platform UI home page opens with cards and navigation menu options that provide access to the instances and other resources that you are authorized to create, manage, or use. For information about completing administration tasks (such as user management or platform customization) from this page, see Platform UI in the IBM Cloud Pak foundational services documentation.
  
  From the navigation menu , expand Administration and click Integration instances.
From the Instances (or Integration instances) page, locate the App Connect Designer (Integration design) instance that you want to update.
Click the options icon to open the options menu, and then click Edit. The "Edit" page opens for that instance.
Either use the fields in the "UI form" view or switch to the YAML view to update the required settings. You can update existing values, add new entries, or delete entries. For information about the available parameters and their values, see Custom resource values.
Click Update to save your changes.

Updating an instance from the Red Hat OpenShift web console

To update an App Connect Designer instance by using the Red Hat OpenShift web console, complete the following steps:

From a browser window, log in to the Red Hat OpenShift Container Platform web console. Ensure that you are in the Administrator perspective .
From the navigation, click Operators > Installed Operators.
If required, select the namespace (project) in which you installed the IBM App Connect Operator.
From the Installed Operators page, click IBM App Connect.
From the Operator details page for the App Connect Operator, click the Designer Authoring tab.
Locate and click the name of the instance that you want to update.
Click the YAML tab.
Update the content of the YAML editor as required. You can update existing values, add new entries, or delete entries. For information about the available parameters and their values, see Custom resource values.
Click Save to save your changes.

Updating an instance from the Red Hat OpenShift CLI or Kubernetes CLI

To update an App Connect Designer instance from the Red Hat OpenShift CLI, complete the following steps.

From the command line, log in to your Red Hat OpenShift cluster by using the oc login command.
From the namespace where the Designer instance is deployed, run the oc edit command to partially update the instance, where instanceName is the name (metadata.name value) of the instance.
```
oc edit designerauthoring instanceName
```
The Designer CR automatically opens in the default text editor for your operating system.
Update the contents of the file as required. You can update existing values, add new entries, or delete entries. For information about the available parameters and their values, see Custom resource values.
Save the YAML definition and close the text editor to apply the changes.

Tip:

If preferred, you can also use the oc patch command to apply a patch with some bash shell features, or use oc apply with the appropriate YAML settings.

For example, you can save the YAML settings to a file with a .yaml extension (for example, updatesettings.yaml), and then run oc patch as follows to update the settings for an instance:

oc patch designerauthoring instanceName --type='merge' --patch "$(cat updatesettings.yaml)"

Deleting an instance

If no longer required, you can delete an App Connect Designer instance. You can do so from the IBM Cloud Pak Platform UI, the Red Hat OpenShift web console or CLI, or the CLI for a Kubernetes environment.

Ensure that you have cluster administrator authority or have been granted the appropriate role-based access control (RBAC).

Note:

If you have an App Connect Designer instance for which incremental learning is enabled with S3 storage, the associated AI model (in ZIP format) will be retained in the S3 bucket when you delete the instance. You can delete the model from the bucket if no longer required.

Delete options:

Deleting an instance from the IBM Cloud Pak Platform UI
Deleting an instance from the Red Hat OpenShift web console
Deleting an instance from the Red Hat OpenShift CLI or Kubernetes CLI

Deleting an instance from the IBM Cloud Pak Platform UI

To delete an App Connect Designer instance from the IBM Cloud Pak Platform UI, complete the following steps:

From a browser window, log in to the Platform UI.
Tip: You can use the generated URL for a deployed IBM Cloud Pak for Integration Platform UI instance to access the Platform UI.
- Applicable to IBM App Connect Operator 11.0.0 or later: The Platform UI Instances page opens as the home page. The welcome banner includes a theme switcher that you can use to choose a light theme, a dark theme, or a custom theme that matches your existing system UI.
- Applicable to IBM App Connect Operator 10.1.1 or earlier: The Platform UI home page opens with cards and navigation menu options that provide access to the instances and other resources that you are authorized to create, manage, or use. For information about completing administration tasks (such as user management or platform customization) from this page, see Platform UI in the IBM Cloud Pak foundational services documentation.
  
  From the navigation menu , expand Administration and click Integration instances.
From the Instances (or Integration instances) page, locate the App Connect Designer (Integration design) instance that you want to delete.
Click the options icon () to open the options menu, and then click Delete.
Confirm the deletion.

Deleting an instance from the Red Hat OpenShift web console

To delete an App Connect Designer instance by using the Red Hat OpenShift web console, complete the following steps:

From a browser window, log in to the Red Hat OpenShift Container Platform web console. Ensure that you are in the Administrator perspective .
From the navigation, click Operators > Installed Operators.
If required, select the namespace (project) in which you installed the IBM App Connect Operator.
From the Installed Operators page, click IBM App Connect.
From the Operator details page for the App Connect Operator, click the Designer Authoring tab.
Locate the instance that you want to delete.
Click the options icon () to open the options menu, and then click the Delete option.
Confirm the deletion.

Deleting an instance from the Red Hat OpenShift CLI or Kubernetes CLI

To delete an App Connect Designer instance from the Red Hat OpenShift CLI, complete the following steps.

From the command line, log in to your Red Hat OpenShift cluster by using the oc login command.
From the namespace where the Designer instance is deployed, run the following command to delete the instance, where instanceName is the value of the metadata.name parameter.
```
oc delete designerauthoring instanceName
```

Validation for custom resource values

Limits on length of name and namespace when creating resources: To allow for valid routes and child objects with names that are derived from the CR name, limit the length of the CR name:
- If the namespace name is too long, routes will not work. The name value that you specify should be less than maxNameLength always.
- DesignerAuthoring has a smaller maxNameLength than the other custom resources because it creates an integration server.
- Allow 12 characters for suffixes that are added to child resources.
- If a namespace name is 40 characters in length, then 10 characters are available for the CR name for DesignerAuthoring.
A storage class must be provided when using persistent storage with CouchDB.
The number of replicas, storage type, storage class, or storage size of the CouchDB server cannot be modified after creation.

Custom resource values

The following table lists the configurable parameters and default values for the custom resource.

Parameter	Description	Default
apiVersion	The API version that identifies which schema is used for this instance.	`appconnect.ibm.com/v1beta1`
kind	The resource type.	`DesignerAuthoring`
metadata.name	A unique short name by which the Designer instance can be identified.
metadata.namespace	The namespace (project) in which the Designer instance is installed. The namespace in which you create an instance or object must be no more than 40 characters in length.
spec.authentication.integrationKeycloak.enabled (Only applicable if spec.version resolves to 12.0.10.0-r2-lts or later) (Not applicable in a Kubernetes environment)	Indicate whether to control access to the instance by using identity and access management (IAM), which is implemented by using Keycloak. Valid values are `true` and `false`. Must be set to `true` to ensure that user identities can be validated. The spec.authorization.integrationKeycloak.enabled setting must also be set to `true`. Must be set to `false` if you do not want to restrict access to the instance. The spec.authorization.integrationKeycloak.enabled setting must also be set to `false`. Note: You cannot disable IAM by omitting spec.authentication.integrationKeycloak.enabled and spec.authorization.integrationKeycloak.enabled from the CR. If omitted, IAM is enabled by default. For more information, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.	`true`
spec.authorization.integrationKeycloak.enabled (Only applicable if spec.version resolves to 12.0.10.0-r2-lts or later) (Not applicable in a Kubernetes environment)	Indicate whether to control access to the instance by using identity and access management (IAM), which is implemented by using Keycloak. Valid values are `true` and `false`. Must be set to `true` to ensure that access permissions can be granted. The spec.authentication.integrationKeycloak.enabled setting must also be set to `true`. Must be set to `false` if you do not want to restrict access to the instance. The spec.authentication.integrationKeycloak.enabled setting must also be set to `false`. Note: You cannot disable IAM by omitting spec.authentication.integrationKeycloak.enabled and spec.authorization.integrationKeycloak.enabled from the CR. If omitted, IAM is enabled by default. For more information, see Identity and access management for App Connect Designer and App Connect Dashboard instances on Red Hat OpenShift.	`true`
spec.couchdb.logLevel	The level of information that is displayed in the CouchDB logs. Valid values are `info`, `warning`, `error`, `debug`, and `notice`.	`info`
spec.couchdb.replicas	The number of CouchDB replica pods to run between 1-10.	`3`
spec.couchdb.resources.requests.cpu Deprecated: (Only applicable if spec.version resolves to 12.0.4.0-r2 or earlier)	The minimum number of CPU cores that are allocated for running CouchDB. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core). Tip: If spec.version resolves to 12.0.5.0-r1-lts or later, use spec.pod.containers.couchdb.resources.* instead.	`100m`
spec.couchdb.resources.requests.memory Deprecated: (Only applicable if spec.version resolves to 12.0.4.0-r2 or earlier)	The minimum memory (in bytes) that is allocated for running CouchDB. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki. Tip: If spec.version resolves to 12.0.5.0-r1-lts or later, use spec.pod.containers.couchdb.resources.* instead.	`128Mi`
spec.couchdb.storage.class	A supported storage class for your cluster, which should be used to dynamically provision a persistent volume that belongs to that class. For information about persistent storage requirements for CouchDB, see Supported storage types for Apache CouchDB. (Required if spec.couchdb.storage.type is set to `persistent-claim`.)
spec.couchdb.storage.size	The maximum amount of storage required for a persistent volume for CouchDB in decimal or binary format; that is, Gi or G. (Required if spec.couchdb.storage.type is set to `persistent-claim`.)
spec.couchdb.storage.type	The type of storage to use for CouchDB. Valid values are: `persistent-claim`: Choose this option for storage in a persistent volume in the container’s file system. Retains the existing configuration, logs, and persistent messages when pods restart. `ephemeral`: Choose this option for storage in an ephemeral volume that exists only for the lifetime of the pod. For more information, see Supported storage types for Apache CouchDB.
spec.designerFlowsOperationMode	The default value of `local` enables the use of locally deployed connectors in the App Connect Designer instance:	`local`
spec.designerMappingAssist.enabled	Controls deployment of Mapping Assist components. Valid values are `true` and `false`. For more information about Mapping Assist, see Simplifying data mapping and data transformation with AI-powered suggestions.
spec.designerMappingAssist.incrementalLearning.schedule (Only applicable if spec.version resolves to 12.0.1.0-r1 or later)	Determines how often mapping preferences in the Designer instance are collated and used to retrain the supplied artificial intelligence (AI) model that is used to implement the incremental learning feature. Valid values are `Every 15 days` and `Every month`. Required if spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true`.	`Every 15 days`
spec.designerMappingAssist.incrementalLearning.storage.bucket (Only applicable if spec.version resolves to 12.0.1.0-r4 or later)	The name of an existing bucket that is used for object storage in a Simple Storage Service (S3) instance. You must have read/write access to this bucket, which will be used to store the trained AI model for the incremental learning feature. For a list of supported S3 providers and considerations for choosing a bucket, see Supported storage types for the AI model. Required if spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true` and spec.designerMappingAssist.incrementalLearning.storage.type is set to `s3`.
spec.designerMappingAssist.incrementalLearning.storage.claimName (Only applicable if spec.version resolves to 12.0.1.0-r1 or later)	The name of an existing claim that should be used to request a persistent volume (with ReadWriteMany access mode) for storing the AI model for the incremental learning feature. This claim must exist in the same namespace as App Connect Designer. When spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true` and spec.designerMappingAssist.incrementalLearning.storage.type is set to `persistent-claim`, either spec.designerMappingAssist.incrementalLearning.storage.class or spec.designerMappingAssist.incrementalLearning.storage.claimName is required.
spec.designerMappingAssist.incrementalLearning.storage.class (Only applicable if spec.version resolves to 12.0.1.0-r1 or later)	A supported storage class for your cluster, which should be used to dynamically provision a persistent volume that belongs to that class. Incremental learning requires a persistent volume with ReadWriteMany access mode for storing the trained AI model. If using IBM Cloud, set the storage class to `ibmc-file-gold-gid` for best performance. For more information about requirements for the persistent volume, see Supported storage types for the AI model. When spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true` and spec.designerMappingAssist.incrementalLearning.storage.type is set to `persistent-claim`, either spec.designerMappingAssist.incrementalLearning.storage.class or spec.designerMappingAssist.incrementalLearning.storage.claimName is required.
spec.designerMappingAssist.incrementalLearning.storage.host (Only applicable if spec.version resolves to 12.0.1.0-r4 or later)	An endpoint associated with your Simple Storage Service (S3) system, to which the S3 REST API sends requests for reading from and writing to the AI model in the bucket specified in spec.designerMappingAssist.incrementalLearning.storage.bucket. For more information, see Supported storage types for the AI model. Required if spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true` and spec.designerMappingAssist.incrementalLearning.storage.type is set to `s3`.
spec.designerMappingAssist.incrementalLearning.storage.s3Configuration (Only applicable if spec.version resolves to 12.0.1.0-r4 or later)	The name of an existing configuration object of type `S3Credentials`, which stores credentials for accessing the bucket specified in spec.designerMappingAssist.incrementalLearning.storage.bucket. Set this parameter to the metadata.name value that was specified while creating the configuration object. For more information, see Creating a configuration of type S3Credentials for use with App Connect Designer. Required if spec.designerMappingAssist.incrementalLearning.useIncrementalLearning is set to `true` and spec.designerMappingAssist.incrementalLearning.storage.type is set to `s3`.
spec.designerMappingAssist.incrementalLearning.storage.type (Only applicable if spec.version resolves to 12.0.1.0-r4 or later)	The type of storage to use for storing the AI model for the incremental learning feature. Valid values are: `persistent-claim`: Choose this option for storage in a persistent volume in the container’s file system. `s3`: Choose this option for storage in a bucket in a Simple Storage Service (S3) instance. For more information, see Supported storage types for the AI model.
spec.designerMappingAssist.incrementalLearning.useIncrementalLearning (Only applicable if spec.version resolves to 12.0.1.0-r1 or later)	Indicates whether to enable the incremental learning feature, which uses AI modeling to periodically analyze mapping preferences in authored flows and memorize patterns in order to improve the accuracy of suggested mappings. This feature will use an additional 3 CPU and 3Gi of memory. Valid values are `true` and `false`. For more information about incremental learning, see Simplifying data mapping and data transformation with AI-powered suggestions.	`false`
spec.imagePullSecrets.name	An optional list of references to secrets in the same namespace to use for pulling any of the images used. If specified, these secrets will be passed to individual puller implementations for them to use. For example, in the case of Docker, only DockerConfig type secrets are honored. For more information, see https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod.
spec.integrationServer.containers.connectors.image (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	The path to the Docker image.
spec.integrationServer.containers.connectors.imagePullPolicy (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.integrationServer.containers.connectors.resources.limits.cpu (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	The upper limit of CPU core. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core).	`1`
spec.integrationServer.containers.connectors.resources.limits.memory (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	The memory upper limit in bytes. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`512Mi`
spec.integrationServer.containers.connectors.resources.requests.cpu (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`250m`
spec.integrationServer.containers.connectors.resources.requests.memory (Only applicable if spec.version resolves to 11.0.0.10-r2 or earlier)	The minimum memory in bytes. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.integrationServer.containers.designereventflows.image (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The path to the Docker image.
spec.integrationServer.containers.designereventflows.imagePullPolicy (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.integrationServer.containers.designereventflows.resources.limits.cpu (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The upper limit of CPU core. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core).	`1`
spec.integrationServer.containers.designereventflows.resources.limits.memory (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The memory upper limit in bytes. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`512Mi`
spec.integrationServer.containers.designereventflows.resources.requests.cpu (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`250m`
spec.integrationServer.containers.designereventflows.resources.requests.memory (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The minimum memory in bytes. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.integrationServer.containers.designerflows.image	The path to the Docker image.
spec.integrationServer.containers.designerflows.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.integrationServer.containers.designerflows.resources.limits.cpu	The upper limit of CPU core. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core).	`1`
spec.integrationServer.containers.designerflows.resources.limits.memory	The memory upper limit in bytes. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`512Mi`
spec.integrationServer.containers.designerflows.resources.requests.cpu	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`250m`
spec.integrationServer.containers.designerflows.resources.requests.memory	The minimum memory in bytes. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.integrationServer.containers.proxy.image (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The path to the Docker image.
spec.integrationServer.containers.proxy.imagePullPolicy (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.integrationServer.containers.proxy.resources.limits.cpu (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The upper limit of CPU core. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core).	`1`
spec.integrationServer.containers.proxy.resources.limits.memory (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The memory upper limit in bytes. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.integrationServer.containers.proxy.resources.requests.cpu (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.integrationServer.containers.proxy.resources.requests.memory (Only applicable if spec.version resolves to 11.0.0.10-r3-eus, 11.0.0.11-r1, or later)	The minimum memory in bytes. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.integrationServer.containers.runtime.env	Define custom environment variables that will be set and used within the runtime container in the deployment. This parameter exposes the Kubernetes API for declaring environment variables in the container, and as such follows the same schema. Add a name/value pair for each environment variable, as shown in the following example, which sets two environment variables for the container. `spec: integrationServer: containers: runtime: env: - name: MY_CUSTOM_ENV_VAR value: 'true' - name: ANOTHER_ENV_VAR value: '100'` For more information, see Define Environment Variables for a Container in the Kubernetes documentation.
spec.integrationServer.containers.runtime.image	The path to the Docker image.
spec.integrationServer.containers.runtime.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.integrationServer.containers.runtime.resources.limits.cpu	The upper limit of CPU core. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core).	`1`
spec.integrationServer.containers.runtime.resources.limits.memory	The memory upper limit in bytes. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1Gi`
spec.integrationServer.containers.runtime.resources.requests.cpu	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`200m`
spec.integrationServer.containers.runtime.resources.requests.memory	The minimum memory in bytes. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.license.accept	An indication of whether the license should be accepted. Valid values are `true` and `false`. To install, this value must be set to `true`.	`false`
spec.license.license	See Licensing reference for IBM App Connect Operator for the valid values.
spec.license.use	See Licensing reference for IBM App Connect Operator for the valid values.
spec.pod.containers.connectorAuthService.image	The path to the Docker image.
spec.pod.containers.connectorAuthService.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.connectorAuthService.livenessProbe.failureThreshold	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.connectorAuthService.livenessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.connectorAuthService.livenessProbe.periodSeconds	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.connectorAuthService.livenessProbe.timeoutSeconds	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.connectorAuthService.readinessProbe.failureThreshold	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.connectorAuthService.readinessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`30`
spec.pod.containers.connectorAuthService.readinessProbe.periodSeconds	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.connectorAuthService.readinessProbe.timeoutSeconds	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.connectorAuthService.resources.limits.cpu	The upper limit of CPU core that is allocated for running the connector auth service container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.connectorAuthService.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.connectorAuthService.resources.limits.memory	The memory upper limit in bytes that is allocated for running the connector auth service container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.connectorAuthService.resources.requests.cpu	The minimum required CPU core that is allocated for running the connector auth service container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.connectorAuthService.resources.requests.memory	The minimum memory in bytes that is allocated for running the connector auth service container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.couchdb.image (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The path to the Docker image.
spec.pod.containers.couchdb.imagePullPolicy (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.couchdb.livenessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The number of times the liveness probe (which checks whether the CouchDB container is still running) can fail before taking action.	`1`
spec.pod.containers.couchdb.livenessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How long to wait (in seconds) before starting the liveness probe, which checks whether the CouchDB container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.couchdb.livenessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How often (in seconds) to perform the liveness probe that checks whether the CouchDB container is still running.	`5`
spec.pod.containers.couchdb.livenessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How long (in seconds) before the liveness probe (which checks whether the CouchDB container is still running) times out.	`3`
spec.pod.containers.couchdb.readinessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The number of times the readiness probe (which checks whether the CouchDB container is ready) can fail before taking action.	`1`
spec.pod.containers.couchdb.readinessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How long to wait (in seconds) before starting the readiness probe, which checks whether the CouchDB container is ready.	`30`
spec.pod.containers.couchdb.readinessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How often (in seconds) to perform the readiness probe that checks whether the CouchDB container is ready.	`5`
spec.pod.containers.couchdb.readinessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How long (in seconds) before the readiness probe (which checks whether the CouchDB container is ready) times out.	`3`
spec.pod.containers.couchdb.resources.limits.cpu (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The upper limit of CPU core that is allocated for running the CouchDB container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.couchdb.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.couchdb.resources.limits.memory (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The memory upper limit in bytes that is allocated for running the CouchDB container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.couchdb.resources.requests.cpu (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The minimum required CPU core that is allocated for running the CouchDB container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.couchdb.resources.requests.memory (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The minimum memory in bytes that is allocated for running the CouchDB container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.couchdb.startupProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The minimum consecutive failures for the probe to be considered failed after having succeeded. For more information about startup probes, see Protect slow starting containers with startup probes in the Kubernetes documentation.	`150`
spec.pod.containers.couchdb.startupProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The number of seconds after the CouchDB container has started before liveness probes are initiated. For more information, see Container probes.	`0`
spec.pod.containers.couchdb.startupProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	How often (in seconds) to perform the probe.	`2`
spec.pod.containers.couchdb.startupProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.5.0-r1-lts or later)	The number of seconds after which the probe times out. For more information, see Container probes.	`1`
spec.pod.containers.flowdocAuthoring.image (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The path to the Docker image.
spec.pod.containers.flowdocAuthoring.imagePullPolicy (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.flowdocAuthoring.livenessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.flowdocAuthoring.livenessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.flowdocAuthoring.livenessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.flowdocAuthoring.livenessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.flowdocAuthoring.readinessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.flowdocAuthoring.readinessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`30`
spec.pod.containers.flowdocAuthoring.readinessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.flowdocAuthoring.readinessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.flowdocAuthoring.resources.limits.cpu (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The upper limit of CPU core that is allocated for running the flow doc authoring container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.flowdocAuthoring.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.flowdocAuthoring.resources.limits.memory (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The memory upper limit in bytes that is allocated for running the flow doc authoring container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.flowdocAuthoring.resources.requests.cpu (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The minimum required CPU core. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.flowdocAuthoring.resources.requests.memory (Only applicable if spec.version resolves to 12.0.12.0-r2 or earlier)	The minimum memory in bytes that is allocated for running the flow doc authoring container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.flowTestManager.image (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The path to the Docker image.
spec.pod.containers.flowTestManager.imagePullPolicy (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.flowTestManager.livenessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.flowTestManager.livenessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.flowTestManager.livenessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.flowTestManager.livenessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.flowTestManager.readinessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.flowTestManager.readinessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`30`
spec.pod.containers.flowTestManager.readinessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.flowTestManager.readinessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.flowTestManager.resources.limits.cpu (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The upper limit of CPU core that is allocated for running the flow test manager container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.flowTestManager.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.flowTestManager.resources.limits.memory (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The memory upper limit in bytes that is allocated for running the flow test manager container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.flowTestManager.resources.requests.cpu (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The minimum required CPU core that is allocated for running the flow test manager container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.flowTestManager.resources.requests.memory (Only applicable if spec.version resolves to 12.0.12-r1 or earlier)	The minimum memory in bytes that is allocated for running the flow test manager container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.mappingAssist.image	The path to the Docker image.
spec.pod.containers.mappingAssist.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.mappingAssist.livenessProbe.failureThreshold	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.mappingAssist.livenessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.mappingAssist.livenessProbe.periodSeconds	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.mappingAssist.livenessProbe.timeoutSeconds	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.mappingAssist.readinessProbe.failureThreshold	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.mappingAssist.readinessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`30`
spec.pod.containers.mappingAssist.readinessProbe.periodSeconds	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.mappingAssist.readinessProbe.timeoutSeconds	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.mappingAssist.resources.limits.cpu	The upper limit of CPU core that is allocated for running the Mapping Assist container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.mappingAssist.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`2300m` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.mappingAssist.resources.limits.memory	The memory upper limit in bytes that is allocated for running the Mapping Assist container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`2765Mi`
spec.pod.containers.mappingAssist.resources.requests.cpu	The minimum required CPU core that is allocated for running the Mapping Assist container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`800m`
spec.pod.containers.mappingAssist.resources.requests.memory	The minimum memory in bytes that is allocated for running the Mapping Assist container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`900Mi`
spec.pod.containers.proxy.image	The path to the Docker image.
spec.pod.containers.proxy.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.proxy.livenessProbe.failureThreshold	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.proxy.livenessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`60`
spec.pod.containers.proxy.livenessProbe.periodSeconds	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.proxy.livenessProbe.timeoutSeconds	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.proxy.readinessProbe.failureThreshold	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.proxy.readinessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`5`
spec.pod.containers.proxy.readinessProbe.periodSeconds	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.proxy.readinessProbe.timeoutSeconds	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.proxy.resources.limits.cpu	The upper limit of CPU core that is allocated for running the Designer proxy container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.proxy.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.proxy.resources.limits.memory	The memory upper limit in bytes that is allocated for running the Designer proxy container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.proxy.resources.requests.cpu	The minimum required CPU core that is allocated for running the Designer proxy container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`200m`
spec.pod.containers.proxy.resources.requests.memory	The minimum memory in bytes that is allocated for running the Designer proxy container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.runtime.image (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The path to the Docker image.
spec.pod.containers.runtime.imagePullPolicy (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.runtime.livenessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.runtime.livenessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`30`
spec.pod.containers.runtime.livenessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`5`
spec.pod.containers.runtime.livenessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`3`
spec.pod.containers.runtime.readinessProbe.failureThreshold (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.runtime.readinessProbe.initialDelaySeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`30`
spec.pod.containers.runtime.readinessProbe.periodSeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`5`
spec.pod.containers.runtime.readinessProbe.timeoutSeconds (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`3`
spec.pod.containers.runtime.resources.limits.cpu (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The upper limit of CPU core that is allocated for running the Designer runtime container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.runtime.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.runtime.resources.limits.memory (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The memory upper limit in bytes that is allocated for running the Designer runtime container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.runtime.resources.requests.cpu (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The minimum required CPU core that is allocated for running the Designer runtime container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.runtime.resources.requests.memory (Only applicable if spec.version resolves to 12.0.12-r4 or earlier)	The minimum memory in bytes that is allocated for running the Designer runtime container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.pod.containers.ui.image	The path to the Docker image.
spec.pod.containers.ui.imagePullPolicy	corev1.PullPolicy Indicate whether you want images to be pulled every time, never, or only if they're not present. Valid values are `Always`, `Never`, and `IfNotPresent`.	`IfNotPresent`
spec.pod.containers.ui.livenessProbe.failureThreshold	The number of times the liveness probe (which checks whether the container is still running) can fail before taking action.	`1`
spec.pod.containers.ui.livenessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the liveness probe, which checks whether the container is still running. Increase this value if your system cannot start the container in the default time period.	`60`
spec.pod.containers.ui.livenessProbe.periodSeconds	How often (in seconds) to perform the liveness probe that checks whether the container is still running.	`30`
spec.pod.containers.ui.livenessProbe.timeoutSeconds	How long (in seconds) before the liveness probe (which checks whether the container is still running) times out.	`10`
spec.pod.containers.ui.readinessProbe.failureThreshold	The number of times the readiness probe (which checks whether the container is ready) can fail before taking action.	`1`
spec.pod.containers.ui.readinessProbe.initialDelaySeconds	How long to wait (in seconds) before starting the readiness probe, which checks whether the container is ready.	`60`
spec.pod.containers.ui.readinessProbe.periodSeconds	How often (in seconds) to perform the readiness probe that checks whether the container is ready.	`2`
spec.pod.containers.ui.readinessProbe.timeoutSeconds	How long (in seconds) before the readiness probe (which checks whether the container is ready) times out.	`10`
spec.pod.containers.ui.resources.limits.cpu	The upper limit of CPU core that is allocated for running the Designer UI container. Specify integers, fractions (for example, 0.5), or millicores values (for example, 100m, where 100m is equivalent to .1 core). When you create a Designer instance, no CPU limits are set on the resource if spec.version resolves to 12.0.7.0-r1 or later. If required, either use spec.pod.containers.ui.resources.limits.cpu to set the CPU limits, or configure CPU limits for the namespace as described in Configure Memory and CPU Quotas for a Namespace in the Kubernetes documentation.	`1` (when spec.version is 12.0.6.0-r1 or earlier)
spec.pod.containers.ui.resources.limits.memory	The memory upper limit in bytes that is allocated for running the Designer UI container. Specify integers with suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`1024Mi`
spec.pod.containers.ui.resources.requests.cpu	The minimum required CPU core that is allocated for running the Designer UI container. Specify integers, fractions (for example, 0.5), or millicore values (for example, 100m, where 100m is equivalent to .1 core).	`100m`
spec.pod.containers.ui.resources.requests.memory	The minimum memory in bytes that is allocated for running the Designer UI container. Specify integers with one of these suffixes: E, P, T, G, M, K, or power-of-two equivalents: Ei, Pi, Ti, Gi, Mi, Ki.	`256Mi`
spec.replicas	The number of replica pods to run for each deployment. A number between 1-10.	`3`
spec.switchServer.name	The name of an existing switch server that enables secure connectivity when running callable flows in the Designer instance, or when running flows that interact with applications in a private network. The switch server name is the metadata.name value in the switch server custom resource. For information about how to create a switch server, see App Connect Switch Server reference.	`default`
spec.useCommonServices Note: Removed from all instances in IBM App Connect Operator 11.0.0 or later. To enable identity and access management (IAM) with Keycloak, see spec.authentication.integrationKeycloak.enabled and spec.authorization.integrationKeycloak.enabled.	An indication of whether to enable use of IBM Cloud Pak foundational services 3.x.x when using an instance in IBM App Connect Operator 10.1.1 or earlier only. Valid values are `true` and `false`. Must be set to `true` if using an IBM Cloud Pak for Integration license (specified via spec.license.use). Can be set to `true` or `false` if using an App Connect Enterprise license. Must be set to `false` if running in a Kubernetes environment with one of the supported App Connect Enterprise licenses (specified via spec.license.use). Applicable only if spec.version resolves to 11.0.0.11-r2 to 12.0.5.0-r3: When set to `true`, only essential IBM Cloud Pak foundational services are requested, which means that only the Identity and Access Management (IAM) service is installed by default, together with a Common UI component that provides a login page for secure access to the instance. Applicable only if spec.version resolves to 12.0.5.0-r4 or later: If set to `true`, you must ensure that the IBM Cloud Pak foundational services Operator (3.19.x or later 3.x.x) is installed as part of your IBM Cloud Pak for Integration deployment, or is manually installed in the same namespace as your independent deployment of the IBM App Connect Operator. (For more information, see Installing IBM Cloud Pak foundational services.) When spec.useCommonServices is set to `true`, only essential IBM Cloud Pak foundational services are requested, which means that only the Identity and Access Management (IAM) service is installed by default, together with a Common UI component that provides a login page for secure access to the instance.	`false`
spec.version	The product version that the Designer instance is based on. Can be specified by using a channel or as a fully qualified version. If you specify a channel, you must ensure that the license aligns with the latest fully qualified version in the channel. If you are using IBM App Connect Operator 7.1.0 or later, the supported channels or versions will depend on the Red Hat OpenShift version that is installed in your cluster. To view the available values that you can choose from, see spec.version values.	`12.0`

Supported platforms

Red Hat OpenShift: Supports the amd64 and ppc64le CPU architectures, although the Mapping Assist component is unsupported on ppc64le. For more information, see Supported platforms.

Kubernetes environment: Supports only the amd64 CPU architecture. For more information, see Supported operating environment for Kubernetes.