aws-cdk-lib.aws_appmesh.CfnVirtualNode.VirtualNodeSpecProperty

interface VirtualNodeSpecProperty

LanguageType name
.NETAmazon.CDK.AWS.AppMesh.CfnVirtualNode.VirtualNodeSpecProperty
Gogithub.com/aws/aws-cdk-go/awscdk/v2/awsappmesh#CfnVirtualNode_VirtualNodeSpecProperty
Javasoftware.amazon.awscdk.services.appmesh.CfnVirtualNode.VirtualNodeSpecProperty
Pythonaws_cdk.aws_appmesh.CfnVirtualNode.VirtualNodeSpecProperty
TypeScript aws-cdk-lib » aws_appmesh » CfnVirtualNode » VirtualNodeSpecProperty

An object that represents the specification of a virtual node.

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_appmesh as appmesh } from 'aws-cdk-lib';
const virtualNodeSpecProperty: appmesh.CfnVirtualNode.VirtualNodeSpecProperty = {
  backendDefaults: {
    clientPolicy: {
      tls: {
        validation: {
          trust: {
            acm: {
              certificateAuthorityArns: ['certificateAuthorityArns'],
            },
            file: {
              certificateChain: 'certificateChain',
            },
            sds: {
              secretName: 'secretName',
            },
          },

          // the properties below are optional
          subjectAlternativeNames: {
            match: {
              exact: ['exact'],
            },
          },
        },

        // the properties below are optional
        certificate: {
          file: {
            certificateChain: 'certificateChain',
            privateKey: 'privateKey',
          },
          sds: {
            secretName: 'secretName',
          },
        },
        enforce: false,
        ports: [123],
      },
    },
  },
  backends: [{
    virtualService: {
      virtualServiceName: 'virtualServiceName',

      // the properties below are optional
      clientPolicy: {
        tls: {
          validation: {
            trust: {
              acm: {
                certificateAuthorityArns: ['certificateAuthorityArns'],
              },
              file: {
                certificateChain: 'certificateChain',
              },
              sds: {
                secretName: 'secretName',
              },
            },

            // the properties below are optional
            subjectAlternativeNames: {
              match: {
                exact: ['exact'],
              },
            },
          },

          // the properties below are optional
          certificate: {
            file: {
              certificateChain: 'certificateChain',
              privateKey: 'privateKey',
            },
            sds: {
              secretName: 'secretName',
            },
          },
          enforce: false,
          ports: [123],
        },
      },
    },
  }],
  listeners: [{
    portMapping: {
      port: 123,
      protocol: 'protocol',
    },

    // the properties below are optional
    connectionPool: {
      grpc: {
        maxRequests: 123,
      },
      http: {
        maxConnections: 123,

        // the properties below are optional
        maxPendingRequests: 123,
      },
      http2: {
        maxRequests: 123,
      },
      tcp: {
        maxConnections: 123,
      },
    },
    healthCheck: {
      healthyThreshold: 123,
      intervalMillis: 123,
      protocol: 'protocol',
      timeoutMillis: 123,
      unhealthyThreshold: 123,

      // the properties below are optional
      path: 'path',
      port: 123,
    },
    outlierDetection: {
      baseEjectionDuration: {
        unit: 'unit',
        value: 123,
      },
      interval: {
        unit: 'unit',
        value: 123,
      },
      maxEjectionPercent: 123,
      maxServerErrors: 123,
    },
    timeout: {
      grpc: {
        idle: {
          unit: 'unit',
          value: 123,
        },
        perRequest: {
          unit: 'unit',
          value: 123,
        },
      },
      http: {
        idle: {
          unit: 'unit',
          value: 123,
        },
        perRequest: {
          unit: 'unit',
          value: 123,
        },
      },
      http2: {
        idle: {
          unit: 'unit',
          value: 123,
        },
        perRequest: {
          unit: 'unit',
          value: 123,
        },
      },
      tcp: {
        idle: {
          unit: 'unit',
          value: 123,
        },
      },
    },
    tls: {
      certificate: {
        acm: {
          certificateArn: 'certificateArn',
        },
        file: {
          certificateChain: 'certificateChain',
          privateKey: 'privateKey',
        },
        sds: {
          secretName: 'secretName',
        },
      },
      mode: 'mode',

      // the properties below are optional
      validation: {
        trust: {
          file: {
            certificateChain: 'certificateChain',
          },
          sds: {
            secretName: 'secretName',
          },
        },

        // the properties below are optional
        subjectAlternativeNames: {
          match: {
            exact: ['exact'],
          },
        },
      },
    },
  }],
  logging: {
    accessLog: {
      file: {
        path: 'path',

        // the properties below are optional
        format: {
          json: [{
            key: 'key',
            value: 'value',
          }],
          text: 'text',
        },
      },
    },
  },
  serviceDiscovery: {
    awsCloudMap: {
      namespaceName: 'namespaceName',
      serviceName: 'serviceName',

      // the properties below are optional
      attributes: [{
        key: 'key',
        value: 'value',
      }],
      ipPreference: 'ipPreference',
    },
    dns: {
      hostname: 'hostname',

      // the properties below are optional
      ipPreference: 'ipPreference',
      responseType: 'responseType',
    },
  },
};

Properties

NameTypeDescription
backendDefaults?IResolvable | BackendDefaultsPropertyA reference to an object that represents the defaults for backends.
backends?IResolvable | IResolvable | BackendProperty[]The backends that the virtual node is expected to send outbound traffic to.
listeners?IResolvable | IResolvable | ListenerProperty[]The listener that the virtual node is expected to receive inbound traffic from.
logging?IResolvable | LoggingPropertyThe inbound and outbound access logging information for the virtual node.
serviceDiscovery?IResolvable | ServiceDiscoveryPropertyThe service discovery information for the virtual node.

backendDefaults?

Type: IResolvable | BackendDefaultsProperty (optional)

A reference to an object that represents the defaults for backends.


backends?

Type: IResolvable | IResolvable | BackendProperty[] (optional)

The backends that the virtual node is expected to send outbound traffic to.

App Mesh doesn't validate the existence of those virtual services specified in backends. This is to prevent a cyclic dependency between virtual nodes and virtual services creation. Make sure the virtual service name is correct. The virtual service can be created afterwards if it doesn't already exist.


listeners?

Type: IResolvable | IResolvable | ListenerProperty[] (optional)

The listener that the virtual node is expected to receive inbound traffic from.

You can specify one listener.


logging?

Type: IResolvable | LoggingProperty (optional)

The inbound and outbound access logging information for the virtual node.


serviceDiscovery?

Type: IResolvable | ServiceDiscoveryProperty (optional)

The service discovery information for the virtual node.

If your virtual node does not expect ingress traffic, you can omit this parameter. If you specify a listener , then you must specify service discovery information.