apiVersion: apiextensions.crossplane.io/v1beta1
kind: CompositeResourceDefinition
metadata:
  # XRDs follow the constraints of CRD names. They must be named
  # <plural>.<group>, per the plural and group names configured by the
  # crdSpecTemplate below.
  name: compositemysqlinstances.example.org
spec:
  # Composite resources may optionally expose a connection secret - a Kubernetes
  # Secret containing all of the details a pod might need to connect to the
  # resource. Resources that wish to expose a connection secret must declare
  # what keys they support. These keys form a 'contract' - any composition that
  # intends to be compatible with this resource must compose resources that
  # supply these connection secret keys.
  connectionSecretKeys:
  - username
  - password
  - hostname
  - port
  # You can specify a default Composition resource to be selected if there is
  # no composition selector or reference was supplied on the Custom Resource.
  defaultCompositionRef:
    name: example-azure
  # An enforced composition will be selected for all instances of this type and
  # will override any selectors and references.
  #enforcedCompositionRef:
  #  name: securemysql.acme.org
  group: example.org
  # The defined kind of composite resource.
  names:
    kind: CompositeMySQLInstance
    plural: compositemysqlinstances
  # The kind of claim this composite resource offers. Optional - omit the claim
  # names if you don't wish to offer a claim for this composite resource. Must
  # be different from the composite resource's kind. The established convention
  # is for the claim kind to represent what the resource is, conceptually. e.g.
  # 'MySQLInstance', not `MySQLInstanceClaim`.
  claimNames:
    kind: MySQLInstance
    plural: mysqlinstances
  # A composite resource may be served at multiple versions simultaneously, but
  # all versions must have identical schemas; Crossplane does not yet support
  # conversion between different version schemas.
  versions:
  - name: v1alpha1
    # Served specifies whether this version should be exposed via the API
    # server's REST API.
    served: true
    # Referenceable specifies whether this version may be referenced by a
    # Composition. Exactly one version may be referenceable by Compositions, and
    # that version must be served. The referenceable version will always be the
    # storage version of the underlying CRD.
    referenceable: true
    # This schema defines the configuration fields that the composite resource
    # supports. It uses the same structural OpenAPI schema as a Kubernetes CRD
    # - for example, this resource supports a spec.parameters.version enum.
    # The following fields are reserved for Crossplane's use, and will be
    # overwritten if included in this validation schema:
    #
    # - spec.resourceRef
    # - spec.resourceRefs
    # - spec.claimRef
    # - spec.writeConnectionSecretToRef
    # - status.conditions
    schema:
      openAPIV3Schema:
        type: object
        properties:
          spec:
            type: object
            properties:
              parameters:
                type: object
                properties:
                  version:
                    description: MySQL engine version
                    type: string
                    enum: ["5.6", "5.7"]
                  storageGB:
                    type: integer
                  location:
                    description: Geographic location of this MySQL server.
                    type: string
                required:
                - version
                - storageGB
                - location
            required:
            - parameters

apiVersion: apiextensions.crossplane.io/v1beta1
kind: Composition
metadata:
  name: example-azure
  labels:
    purpose: example
    provider: azure
spec:
  # This Composition declares that it satisfies the CompositeMySQLInstance
  # resource defined above - i.e. it patches "from" a CompositeMySQLInstance.
  # Note that the version in apiVersion must be the referenceable version of the
  # XRD.
  compositeTypeRef:
    apiVersion: example.org/v1alpha1
    kind: CompositeMySQLInstance
  # This Composition reconciles a CompositeMySQLInstance by patching from
  # the CompositeMySQLInstance "to" new instances of the infrastructure
  # resources below. These resources may be the managed resources of an
  # infrastructure provider such as provider-azure, or other composite
  # resources.
  resources:
    # A CompositeMySQLInstance that uses this Composition will be composed of an
    # Azure ResourceGroup. The "base" for this ResourceGroup specifies the base
    # configuration that may be extended or mutated by the patches below.
  - base:
      apiVersion: azure.crossplane.io/v1alpha3
      kind: ResourceGroup
      spec: {}
    # Patches copy or "overlay" the value of a field path within the composite
    # resource (the CompositeMySQLInstance) to a field path within the composed
    # resource (the ResourceGroup). In the below example any labels and
    # annotations will be propagated from the CompositeMySQLInstance to the
    # ResourceGroup, as will the location.
    patches:
    - fromFieldPath: "metadata.labels"
      toFieldPath: "metadata.labels"
    - fromFieldPath: "metadata.annotations"
      toFieldPath: "metadata.annotations"
    - fromFieldPath: "spec.parameters.location"
      toFieldPath: "spec.location"
      # Sometimes it is necessary to "transform" the value from the composite
      # resource into a value suitable for the composed resource, for example an
      # Azure based composition may represent geographical locations differently
      # from a GCP based composition that satisfies the same composite resource.
      # This can be done by providing an optional array of transforms, such as
      # the below that will transform the MySQLInstance spec.parameters.location
      # value "us-west" into the ResourceGroup spec.location value "West US".
      transforms:
      - type: map
        map:
          us-west: West US
          us-east: East US
          au-east: Australia East
    # A MySQLInstance that uses this Composition will also be composed of an
    # Azure MySQLServer.
  - base:
      apiVersion: database.azure.crossplane.io/v1beta1
      kind: MySQLServer
      spec:
        forProvider:
          # When this MySQLServer is created it must specify a ResourceGroup in
          # which it will exist. The below resourceGroupNameSelector corresponds
          # to the spec.forProvider.resourceGroupName field of the MySQLServer.
          # It selects a ResourceGroup with a matching controller reference.
          # Two resources that are part of the same composite resource will have
          # matching controller references, so this MySQLServer will always
          # select the ResourceGroup above. If this Composition included more
          # than one ResourceGroup they could be differentiated by matchLabels.
          resourceGroupNameSelector:
            matchControllerRef: true
          administratorLogin: notadmin
          sslEnforcement: Disabled
          sku:
            tier: GeneralPurpose
            capacity: 8
            family: Gen5
          storageProfile:
            backupRetentionDays: 7
            geoRedundantBackup: Disabled
        writeConnectionSecretToRef:
          namespace: crossplane-system
    patches:
    - fromFieldPath: "metadata.labels"
      toFieldPath: "metadata.labels"
    - fromFieldPath: "metadata.annotations"
      toFieldPath: "metadata.annotations"
    - fromFieldPath: "metadata.uid"
      toFieldPath: "spec.writeConnectionSecretToRef.name"
      transforms:
        # Transform the value from the CompositeMySQLInstance using Go string
        # formatting. This can be used to prefix or suffix a string, or to
        # convert a number to a string. See https://golang.org/pkg/fmt/ for more
        # detail.
      - type: string
        string:
          fmt: "%s-mysqlserver"
    - fromFieldPath: "spec.parameters.version"
      toFieldPath: "spec.forProvider.version"
    - fromFieldPath: "spec.parameters.location"
      toFieldPath: "spec.forProvider.location"
      transforms:
      - type: map
        map:
          us-west: West US
          us-east: East US
          au-east: Australia East
    - fromFieldPath: "spec.parameters.storageGB"
      toFieldPath: "spec.forProvider.storageProfile.storageMB"
      # Transform the value from the CompositeMySQLInstance by multiplying it by
      # 1024 to convert Gigabytes to Megabytes.
      transforms:
        - type: math
          math:
            multiply: 1024
    # In addition to a base and patches, this composed MySQLServer declares that
    # it can fulfil the connectionSecretKeys contract required by the definition
    # of the CompositeMySQLInstance. This MySQLServer writes a connection secret
    # with a username, password, and endpoint that may be used to connect to it.
    # These connection details will also be exposed via the composite resource's
    # connection secret. Exactly one composed resource must provide each secret
    # key, but different composed resources may provide different keys.
    connectionDetails:
    - fromConnectionSecretKey: username
    - fromConnectionSecretKey: password
      # The name of the required CompositeMySQLInstance connection secret key
      # can be supplied if it is different from the connection secret key
      # exposed by the MySQLServer.
    - name: hostname
      fromConnectionSecretKey: endpoint
      # In some cases it may be desirable to inject a fixed connection secret
      # value, for example to expose fixed, non-sensitive connection details
      # like standard ports that are not published to the composed resource's
      # connection secret.
    - name: port
      value: "3306"
    # A CompositeMySQLInstance that uses this Composition will also be composed
    # of an Azure MySQLServerFirewallRule.
  - base:
      apiVersion: database.azure.crossplane.io/v1alpha3
      kind: MySQLServerFirewallRule
      spec:
        forProvider:
          resourceGroupNameSelector:
            matchControllerRef: true
          serverNameSelector:
            matchControllerRef: true
          properties:
            startIpAddress: 10.10.0.0
            endIpAddress: 10.10.255.254
            virtualNetworkSubnetIdSelector:
              name: sample-subnet
    patches:
    - fromFieldPath: "metadata.labels"
      toFieldPath: "metadata.labels"
    - fromFieldPath: "metadata.annotations"
      toFieldPath: "metadata.annotations"
  # Some composite resources may be "dynamically provisioned" - i.e. provisioned
  # on-demand to satisfy an application's claim for infrastructure. The
  # writeConnectionSecretsToNamespace field configures the default value used
  # when dynamically provisioning a composite resource; it is explained in more
  # detail below.
  writeConnectionSecretsToNamespace: crossplane-system

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
  annotations:
    example.org/a: example-annotation
spec:
  containers:
  - name: example-container
    image: example:latest
    command: [example]
    args: ["--debug", "--example"]

apiVersion: example.org/v1alpha1
kind: CompositeMySQLInstance
metadata:
  # Composite resources are cluster scoped, so there's no need for a namespace.
  name: example
spec:
  # The schema of the spec.parameters object is defined by the earlier example
  # of an CompositeResourceDefinition. The location, storageGB, and version fields
  # are patched onto the ResourceGroup, MySQLServer, and MySQLServerFirewallRule
  # that this MySQLInstance composes.
  parameters:
    location: au-east
    storageGB: 20
    version: "5.7"
  # Support for a compositionRef is automatically injected into the schema of
  # all defined composite resources. This allows the resource
  # author to explicitly reference a Composition that this composite resource
  # should use - in this case the earlier example-azure Composition. Note that
  # it is also possible to select a composition by labels - see the below
  # MySQLInstance for an example of this approach.
  compositionRef:
    name: example-azure
  # Support for a writeConnectionSecretToRef is automatically injected into the
  # schema of all defined composite resources. This allows the
  # resource to write a connection secret containing any details required to
  # connect to it - in this case the hostname, username, and password. Composite
  # resource authors may omit this reference if they do not need or wish to
  # write these details.
  writeConnectionSecretToRef:
    namespace: infra-secrets
    name: example-mysqlinstance

# The MySQLInstance always has the same API group and version as the
# resource it requires. Its kind is always suffixed with .
apiVersion: example.org/v1alpha1
kind: MySQLInstance
metadata:
  # Infrastructure claims are namespaced.
  namespace: default
  name: example
spec:
  # The schema of the spec.parameters object is defined by the earlier example
  # of an CompositeResourceDefinition. The location, storageGB, and version fields
  # are patched onto the ResourceGroup, MySQLServer, and MySQLServerFirewallRule
  # composed by the required MySQLInstance.
  parameters:
    location: au-east
    storageGB: 20
    version: "5.7"
  # Support for a resourceRef is automatically injected into the schema of all
  # resource claims. The resourceRef requests a CompositeMySQLInstance
  # explicitly.
  resourceRef:
    apiVersion: example.org/v1alpha1
    kind: CompositeMySQLInstance
    name: example
  # Support for a writeConnectionSecretToRef is automatically injected into the
  # schema of all published infrastructure claim resources. This allows
  # the resource to write a connection secret containing any details required to
  # connect to it - in this case the hostname, username, and password.
  writeConnectionSecretToRef:
    name: example-mysqlinstance

apiVersion: example.org/v1alpha1
kind: MySQLInstance
metadata:
  namespace: default
  name: example
spec:
  parameters:
    location: au-east
    storageGB: 20
    version: "5.7"
  # Support for a compositionSelector is automatically injected into the schema
  # of all published infrastructure claim resources. This selector selects
  # the example-azure composition by its labels.
  compositionSelector:
    matchLabels:
      purpose: example
      provider: azure
  writeConnectionSecretToRef:
    name: example-mysqlinstance