...

Text file src/github.com/linkerd/linkerd2/charts/linkerd-crds/templates/gateway.networking.k8s.io_grpcroutes.yaml

Documentation: github.com/linkerd/linkerd2/charts/linkerd-crds/templates

     1{{- if .Values.enableHttpRoutes }}
     2---
     3apiVersion: apiextensions.k8s.io/v1
     4kind: CustomResourceDefinition
     5metadata:
     6  annotations:
     7    api-approved.kubernetes.io: https://github.com/kubernetes-sigs/gateway-api/pull/1923
     8    gateway.networking.k8s.io/bundle-version: v0.7.1
     9    gateway.networking.k8s.io/channel: experimental
    10    {{ include "partials.annotations.created-by" . }}
    11  labels:
    12    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
    13    linkerd.io/control-plane-ns: {{.Release.Namespace}}
    14  creationTimestamp: null
    15  name: grpcroutes.gateway.networking.k8s.io
    16spec:
    17  group: gateway.networking.k8s.io
    18  names:
    19    categories:
    20    - gateway-api
    21    kind: GRPCRoute
    22    listKind: GRPCRouteList
    23    plural: grpcroutes
    24    singular: grpcroute
    25  scope: Namespaced
    26  versions:
    27  - additionalPrinterColumns:
    28    - jsonPath: .spec.hostnames
    29      name: Hostnames
    30      type: string
    31    - jsonPath: .metadata.creationTimestamp
    32      name: Age
    33      type: date
    34    name: v1alpha2
    35    schema:
    36      openAPIV3Schema:
    37        description: "GRPCRoute provides a way to route gRPC requests. This includes
    38          the capability to match requests by hostname, gRPC service, gRPC method,
    39          or HTTP/2 header. Filters can be used to specify additional processing steps.
    40          Backends specify where matching requests will be routed. \n GRPCRoute falls
    41          under extended support within the Gateway API. Within the following specification,
    42          the word \"MUST\" indicates that an implementation supporting GRPCRoute
    43          must conform to the indicated requirement, but an implementation not supporting
    44          this route type need not follow the requirement unless explicitly indicated.
    45          \n Implementations supporting `GRPCRoute` with the `HTTPS` `ProtocolType`
    46          MUST accept HTTP/2 connections without an initial upgrade from HTTP/1.1,
    47          i.e. via ALPN. If the implementation does not support this, then it MUST
    48          set the \"Accepted\" condition to \"False\" for the affected listener with
    49          a reason of \"UnsupportedProtocol\".  Implementations MAY also accept HTTP/2
    50          connections with an upgrade from HTTP/1. \n Implementations supporting `GRPCRoute`
    51          with the `HTTP` `ProtocolType` MUST support HTTP/2 over cleartext TCP (h2c,
    52          https://www.rfc-editor.org/rfc/rfc7540#section-3.1) without an initial upgrade
    53          from HTTP/1.1, i.e. with prior knowledge (https://www.rfc-editor.org/rfc/rfc7540#section-3.4).
    54          If the implementation does not support this, then it MUST set the \"Accepted\"
    55          condition to \"False\" for the affected listener with a reason of \"UnsupportedProtocol\".
    56          Implementations MAY also accept HTTP/2 connections with an upgrade from
    57          HTTP/1, i.e. without prior knowledge. \n Support: Extended"
    58        properties:
    59          apiVersion:
    60            description: 'APIVersion defines the versioned schema of this representation
    61              of an object. Servers should convert recognized schemas to the latest
    62              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
    63            type: string
    64          kind:
    65            description: 'Kind is a string value representing the REST resource this
    66              object represents. Servers may infer this from the endpoint the client
    67              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
    68            type: string
    69          metadata:
    70            type: object
    71          spec:
    72            description: Spec defines the desired state of GRPCRoute.
    73            properties:
    74              hostnames:
    75                description: "Hostnames defines a set of hostnames to match against
    76                  the GRPC Host header to select a GRPCRoute to process the request.
    77                  This matches the RFC 1123 definition of a hostname with 2 notable
    78                  exceptions: \n 1. IPs are not allowed. 2. A hostname may be prefixed
    79                  with a wildcard label (`*.`). The wildcard label MUST appear by
    80                  itself as the first label. \n If a hostname is specified by both
    81                  the Listener and GRPCRoute, there MUST be at least one intersecting
    82                  hostname for the GRPCRoute to be attached to the Listener. For example:
    83                  \n * A Listener with `test.example.com` as the hostname matches
    84                  GRPCRoutes that have either not specified any hostnames, or have
    85                  specified at least one of `test.example.com` or `*.example.com`.
    86                  * A Listener with `*.example.com` as the hostname matches GRPCRoutes
    87                  that have either not specified any hostnames or have specified at
    88                  least one hostname that matches the Listener hostname. For example,
    89                  `test.example.com` and `*.example.com` would both match. On the
    90                  other hand, `example.com` and `test.example.net` would not match.
    91                  \n Hostnames that are prefixed with a wildcard label (`*.`) are
    92                  interpreted as a suffix match. That means that a match for `*.example.com`
    93                  would match both `test.example.com`, and `foo.test.example.com`,
    94                  but not `example.com`. \n If both the Listener and GRPCRoute have
    95                  specified hostnames, any GRPCRoute hostnames that do not match the
    96                  Listener hostname MUST be ignored. For example, if a Listener specified
    97                  `*.example.com`, and the GRPCRoute specified `test.example.com`
    98                  and `test.example.net`, `test.example.net` MUST NOT be considered
    99                  for a match. \n If both the Listener and GRPCRoute have specified
   100                  hostnames, and none match with the criteria above, then the GRPCRoute
   101                  MUST NOT be accepted by the implementation. The implementation MUST
   102                  raise an 'Accepted' Condition with a status of `False` in the corresponding
   103                  RouteParentStatus. \n If a Route (A) of type HTTPRoute or GRPCRoute
   104                  is attached to a Listener and that listener already has another
   105                  Route (B) of the other type attached and the intersection of the
   106                  hostnames of A and B is non-empty, then the implementation MUST
   107                  accept exactly one of these two routes, determined by the following
   108                  criteria, in order: \n * The oldest Route based on creation timestamp.
   109                  * The Route appearing first in alphabetical order by \"{namespace}/{name}\".
   110                  \n The rejected Route MUST raise an 'Accepted' condition with a
   111                  status of 'False' in the corresponding RouteParentStatus. \n Support:
   112                  Core"
   113                items:
   114                  description: "Hostname is the fully qualified domain name of a network
   115                    host. This matches the RFC 1123 definition of a hostname with
   116                    2 notable exceptions: \n 1. IPs are not allowed. 2. A hostname
   117                    may be prefixed with a wildcard label (`*.`). The wildcard label
   118                    must appear by itself as the first label. \n Hostname can be \"precise\"
   119                    which is a domain name without the terminating dot of a network
   120                    host (e.g. \"foo.example.com\") or \"wildcard\", which is a domain
   121                    name prefixed with a single wildcard label (e.g. `*.example.com`).
   122                    \n Note that as per RFC1035 and RFC1123, a *label* must consist
   123                    of lower case alphanumeric characters or '-', and must start and
   124                    end with an alphanumeric character. No other punctuation is allowed."
   125                  maxLength: 253
   126                  minLength: 1
   127                  pattern: ^(\*\.)?[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   128                  type: string
   129                maxItems: 16
   130                type: array
   131              parentRefs:
   132                description: "ParentRefs references the resources (usually Gateways)
   133                  that a Route wants to be attached to. Note that the referenced parent
   134                  resource needs to allow this for the attachment to be complete.
   135                  For Gateways, that means the Gateway needs to allow attachment from
   136                  Routes of this kind and namespace. \n The only kind of parent resource
   137                  with \"Core\" support is Gateway. This API may be extended in the
   138                  future to support additional kinds of parent resources such as one
   139                  of the route kinds. \n It is invalid to reference an identical parent
   140                  more than once. It is valid to reference multiple distinct sections
   141                  within the same parent resource, such as 2 Listeners within a Gateway.
   142                  \n It is possible to separately reference multiple distinct objects
   143                  that may be collapsed by an implementation. For example, some implementations
   144                  may choose to merge compatible Gateway Listeners together. If that
   145                  is the case, the list of routes attached to those resources should
   146                  also be merged. \n Note that for ParentRefs that cross namespace
   147                  boundaries, there are specific rules. Cross-namespace references
   148                  are only valid if they are explicitly allowed by something in the
   149                  namespace they are referring to. For example, Gateway has the AllowedRoutes
   150                  field, and ReferenceGrant provides a generic way to enable any other
   151                  kind of cross-namespace reference."
   152                items:
   153                  description: "ParentReference identifies an API object (usually
   154                    a Gateway) that can be considered a parent of this resource (usually
   155                    a route). The only kind of parent resource with \"Core\" support
   156                    is Gateway. This API may be extended in the future to support
   157                    additional kinds of parent resources, such as HTTPRoute. \n The
   158                    API object must be valid in the cluster; the Group and Kind must
   159                    be registered in the cluster for this reference to be valid."
   160                  properties:
   161                    group:
   162                      default: gateway.networking.k8s.io
   163                      description: "Group is the group of the referent. When unspecified,
   164                        \"gateway.networking.k8s.io\" is inferred. To set the core
   165                        API group (such as for a \"Service\" kind referent), Group
   166                        must be explicitly set to \"\" (empty string). \n Support:
   167                        Core"
   168                      maxLength: 253
   169                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   170                      type: string
   171                    kind:
   172                      default: Gateway
   173                      description: "Kind is kind of the referent. \n Support: Core
   174                        (Gateway) \n Support: Implementation-specific (Other Resources)"
   175                      maxLength: 63
   176                      minLength: 1
   177                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   178                      type: string
   179                    name:
   180                      description: "Name is the name of the referent. \n Support:
   181                        Core"
   182                      maxLength: 253
   183                      minLength: 1
   184                      type: string
   185                    namespace:
   186                      description: "Namespace is the namespace of the referent. When
   187                        unspecified, this refers to the local namespace of the Route.
   188                        \n Note that there are specific rules for ParentRefs which
   189                        cross namespace boundaries. Cross-namespace references are
   190                        only valid if they are explicitly allowed by something in
   191                        the namespace they are referring to. For example: Gateway
   192                        has the AllowedRoutes field, and ReferenceGrant provides a
   193                        generic way to enable any other kind of cross-namespace reference.
   194                        \n Support: Core"
   195                      maxLength: 63
   196                      minLength: 1
   197                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   198                      type: string
   199                    port:
   200                      description: "Port is the network port this Route targets. It
   201                        can be interpreted differently based on the type of parent
   202                        resource. \n When the parent resource is a Gateway, this targets
   203                        all listeners listening on the specified port that also support
   204                        this kind of Route(and select this Route). It's not recommended
   205                        to set `Port` unless the networking behaviors specified in
   206                        a Route must apply to a specific port as opposed to a listener(s)
   207                        whose port(s) may be changed. When both Port and SectionName
   208                        are specified, the name and port of the selected listener
   209                        must match both specified values. \n Implementations MAY choose
   210                        to support other parent resources. Implementations supporting
   211                        other types of parent resources MUST clearly document how/if
   212                        Port is interpreted. \n For the purpose of status, an attachment
   213                        is considered successful as long as the parent resource accepts
   214                        it partially. For example, Gateway listeners can restrict
   215                        which Routes can attach to them by Route kind, namespace,
   216                        or hostname. If 1 of 2 Gateway listeners accept attachment
   217                        from the referencing Route, the Route MUST be considered successfully
   218                        attached. If no Gateway listeners accept attachment from this
   219                        Route, the Route MUST be considered detached from the Gateway.
   220                        \n Support: Extended \n <gateway:experimental>"
   221                      format: int32
   222                      maximum: 65535
   223                      minimum: 1
   224                      type: integer
   225                    sectionName:
   226                      description: "SectionName is the name of a section within the
   227                        target resource. In the following resources, SectionName is
   228                        interpreted as the following: \n * Gateway: Listener Name.
   229                        When both Port (experimental) and SectionName are specified,
   230                        the name and port of the selected listener must match both
   231                        specified values. \n Implementations MAY choose to support
   232                        attaching Routes to other resources. If that is the case,
   233                        they MUST clearly document how SectionName is interpreted.
   234                        \n When unspecified (empty string), this will reference the
   235                        entire resource. For the purpose of status, an attachment
   236                        is considered successful if at least one section in the parent
   237                        resource accepts it. For example, Gateway listeners can restrict
   238                        which Routes can attach to them by Route kind, namespace,
   239                        or hostname. If 1 of 2 Gateway listeners accept attachment
   240                        from the referencing Route, the Route MUST be considered successfully
   241                        attached. If no Gateway listeners accept attachment from this
   242                        Route, the Route MUST be considered detached from the Gateway.
   243                        \n Support: Core"
   244                      maxLength: 253
   245                      minLength: 1
   246                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   247                      type: string
   248                  required:
   249                  - name
   250                  type: object
   251                maxItems: 32
   252                type: array
   253              rules:
   254                default:
   255                - matches:
   256                  - method:
   257                      type: Exact
   258                description: Rules are a list of GRPC matchers, filters and actions.
   259                items:
   260                  description: GRPCRouteRule defines the semantics for matching a
   261                    gRPC request based on conditions (matches), processing it (filters),
   262                    and forwarding the request to an API object (backendRefs).
   263                  properties:
   264                    backendRefs:
   265                      description: "BackendRefs defines the backend(s) where matching
   266                        requests should be sent. \n Failure behavior here depends
   267                        on how many BackendRefs are specified and how many are invalid.
   268                        \n If *all* entries in BackendRefs are invalid, and there
   269                        are also no filters specified in this route rule, *all* traffic
   270                        which matches this rule MUST receive an `UNAVAILABLE` status.
   271                        \n See the GRPCBackendRef definition for the rules about what
   272                        makes a single GRPCBackendRef invalid. \n When a GRPCBackendRef
   273                        is invalid, `UNAVAILABLE` statuses MUST be returned for requests
   274                        that would have otherwise been routed to an invalid backend.
   275                        If multiple backends are specified, and some are invalid,
   276                        the proportion of requests that would otherwise have been
   277                        routed to an invalid backend MUST receive an `UNAVAILABLE`
   278                        status. \n For example, if two backends are specified with
   279                        equal weights, and one is invalid, 50 percent of traffic MUST
   280                        receive an `UNAVAILABLE` status. Implementations may choose
   281                        how that 50 percent is determined. \n Support: Core for Kubernetes
   282                        Service \n Support: Implementation-specific for any other
   283                        resource \n Support for weight: Core"
   284                      items:
   285                        description: GRPCBackendRef defines how a GRPCRoute forwards
   286                          a gRPC request.
   287                        properties:
   288                          filters:
   289                            description: "Filters defined at this level MUST be executed
   290                              if and only if the request is being forwarded to the
   291                              backend defined here. \n Support: Implementation-specific
   292                              (For broader support of filters, use the Filters field
   293                              in GRPCRouteRule.)"
   294                            items:
   295                              description: GRPCRouteFilter defines processing steps
   296                                that must be completed during the request or response
   297                                lifecycle. GRPCRouteFilters are meant as an extension
   298                                point to express processing that may be done in Gateway
   299                                implementations. Some examples include request or
   300                                response modification, implementing authentication
   301                                strategies, rate-limiting, and traffic shaping. API
   302                                guarantee/conformance is defined based on the type
   303                                of the filter.
   304                              properties:
   305                                extensionRef:
   306                                  description: "ExtensionRef is an optional, implementation-specific
   307                                    extension to the \"filter\" behavior.  For example,
   308                                    resource \"myroutefilter\" in group \"networking.example.net\").
   309                                    ExtensionRef MUST NOT be used for core and extended
   310                                    filters. \n Support: Implementation-specific"
   311                                  properties:
   312                                    group:
   313                                      description: Group is the group of the referent.
   314                                        For example, "gateway.networking.k8s.io".
   315                                        When unspecified or empty string, core API
   316                                        group is inferred.
   317                                      maxLength: 253
   318                                      pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   319                                      type: string
   320                                    kind:
   321                                      description: Kind is kind of the referent. For
   322                                        example "HTTPRoute" or "Service".
   323                                      maxLength: 63
   324                                      minLength: 1
   325                                      pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   326                                      type: string
   327                                    name:
   328                                      description: Name is the name of the referent.
   329                                      maxLength: 253
   330                                      minLength: 1
   331                                      type: string
   332                                  required:
   333                                  - group
   334                                  - kind
   335                                  - name
   336                                  type: object
   337                                requestHeaderModifier:
   338                                  description: "RequestHeaderModifier defines a schema
   339                                    for a filter that modifies request headers. \n
   340                                    Support: Core"
   341                                  properties:
   342                                    add:
   343                                      description: "Add adds the given header(s) (name,
   344                                        value) to the request before the action. It
   345                                        appends to any existing values associated
   346                                        with the header name. \n Input: GET /foo HTTP/1.1
   347                                        my-header: foo \n Config: add: - name: \"my-header\"
   348                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   349                                        my-header: foo,bar,baz"
   350                                      items:
   351                                        description: HTTPHeader represents an HTTP
   352                                          Header name and value as defined by RFC
   353                                          7230.
   354                                        properties:
   355                                          name:
   356                                            description: "Name is the name of the
   357                                              HTTP Header to be matched. Name matching
   358                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   359                                              \n If multiple entries specify equivalent
   360                                              header names, the first entry with an
   361                                              equivalent name MUST be considered for
   362                                              a match. Subsequent entries with an
   363                                              equivalent header name MUST be ignored.
   364                                              Due to the case-insensitivity of header
   365                                              names, \"foo\" and \"Foo\" are considered
   366                                              equivalent."
   367                                            maxLength: 256
   368                                            minLength: 1
   369                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   370                                            type: string
   371                                          value:
   372                                            description: Value is the value of HTTP
   373                                              Header to be matched.
   374                                            maxLength: 4096
   375                                            minLength: 1
   376                                            type: string
   377                                        required:
   378                                        - name
   379                                        - value
   380                                        type: object
   381                                      maxItems: 16
   382                                      type: array
   383                                      x-kubernetes-list-map-keys:
   384                                      - name
   385                                      x-kubernetes-list-type: map
   386                                    remove:
   387                                      description: "Remove the given header(s) from
   388                                        the HTTP request before the action. The value
   389                                        of Remove is a list of HTTP header names.
   390                                        Note that the header names are case-insensitive
   391                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   392                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   393                                        my-header2: bar my-header3: baz \n Config:
   394                                        remove: [\"my-header1\", \"my-header3\"] \n
   395                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   396                                      items:
   397                                        type: string
   398                                      maxItems: 16
   399                                      type: array
   400                                    set:
   401                                      description: "Set overwrites the request with
   402                                        the given header (name, value) before the
   403                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   404                                        foo \n Config: set: - name: \"my-header\"
   405                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   406                                        my-header: bar"
   407                                      items:
   408                                        description: HTTPHeader represents an HTTP
   409                                          Header name and value as defined by RFC
   410                                          7230.
   411                                        properties:
   412                                          name:
   413                                            description: "Name is the name of the
   414                                              HTTP Header to be matched. Name matching
   415                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   416                                              \n If multiple entries specify equivalent
   417                                              header names, the first entry with an
   418                                              equivalent name MUST be considered for
   419                                              a match. Subsequent entries with an
   420                                              equivalent header name MUST be ignored.
   421                                              Due to the case-insensitivity of header
   422                                              names, \"foo\" and \"Foo\" are considered
   423                                              equivalent."
   424                                            maxLength: 256
   425                                            minLength: 1
   426                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   427                                            type: string
   428                                          value:
   429                                            description: Value is the value of HTTP
   430                                              Header to be matched.
   431                                            maxLength: 4096
   432                                            minLength: 1
   433                                            type: string
   434                                        required:
   435                                        - name
   436                                        - value
   437                                        type: object
   438                                      maxItems: 16
   439                                      type: array
   440                                      x-kubernetes-list-map-keys:
   441                                      - name
   442                                      x-kubernetes-list-type: map
   443                                  type: object
   444                                requestMirror:
   445                                  description: "RequestMirror defines a schema for
   446                                    a filter that mirrors requests. Requests are sent
   447                                    to the specified destination, but responses from
   448                                    that destination are ignored. \n Support: Extended"
   449                                  properties:
   450                                    backendRef:
   451                                      description: "BackendRef references a resource
   452                                        where mirrored requests are sent. \n If the
   453                                        referent cannot be found, this BackendRef
   454                                        is invalid and must be dropped from the Gateway.
   455                                        The controller must ensure the \"ResolvedRefs\"
   456                                        condition on the Route status is set to `status:
   457                                        False` and not configure this backend in the
   458                                        underlying implementation. \n If there is
   459                                        a cross-namespace reference to an *existing*
   460                                        object that is not allowed by a ReferenceGrant,
   461                                        the controller must ensure the \"ResolvedRefs\"
   462                                        \ condition on the Route is set to `status:
   463                                        False`, with the \"RefNotPermitted\" reason
   464                                        and not configure this backend in the underlying
   465                                        implementation. \n In either error case, the
   466                                        Message of the `ResolvedRefs` Condition should
   467                                        be used to provide more detail about the problem.
   468                                        \n Support: Extended for Kubernetes Service
   469                                        \n Support: Implementation-specific for any
   470                                        other resource"
   471                                      properties:
   472                                        group:
   473                                          default: ""
   474                                          description: Group is the group of the referent.
   475                                            For example, "gateway.networking.k8s.io".
   476                                            When unspecified or empty string, core
   477                                            API group is inferred.
   478                                          maxLength: 253
   479                                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   480                                          type: string
   481                                        kind:
   482                                          default: Service
   483                                          description: "Kind is the Kubernetes resource
   484                                            kind of the referent. For example \"Service\".
   485                                            \n Defaults to \"Service\" when not specified.
   486                                            \n ExternalName services can refer to
   487                                            CNAME DNS records that may live outside
   488                                            of the cluster and as such are difficult
   489                                            to reason about in terms of conformance.
   490                                            They also may not be safe to forward to
   491                                            (see CVE-2021-25740 for more information).
   492                                            Implementations SHOULD NOT support ExternalName
   493                                            Services. \n Support: Core (Services with
   494                                            a type other than ExternalName) \n Support:
   495                                            Implementation-specific (Services with
   496                                            type ExternalName)"
   497                                          maxLength: 63
   498                                          minLength: 1
   499                                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   500                                          type: string
   501                                        name:
   502                                          description: Name is the name of the referent.
   503                                          maxLength: 253
   504                                          minLength: 1
   505                                          type: string
   506                                        namespace:
   507                                          description: "Namespace is the namespace
   508                                            of the backend. When unspecified, the
   509                                            local namespace is inferred. \n Note that
   510                                            when a namespace different than the local
   511                                            namespace is specified, a ReferenceGrant
   512                                            object is required in the referent namespace
   513                                            to allow that namespace's owner to accept
   514                                            the reference. See the ReferenceGrant
   515                                            documentation for details. \n Support:
   516                                            Core"
   517                                          maxLength: 63
   518                                          minLength: 1
   519                                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   520                                          type: string
   521                                        port:
   522                                          description: Port specifies the destination
   523                                            port number to use for this resource.
   524                                            Port is required when the referent is
   525                                            a Kubernetes Service. In this case, the
   526                                            port number is the service port number,
   527                                            not the target port. For other resources,
   528                                            destination port might be derived from
   529                                            the referent resource or this field.
   530                                          format: int32
   531                                          maximum: 65535
   532                                          minimum: 1
   533                                          type: integer
   534                                      required:
   535                                      - name
   536                                      type: object
   537                                  required:
   538                                  - backendRef
   539                                  type: object
   540                                responseHeaderModifier:
   541                                  description: "ResponseHeaderModifier defines a schema
   542                                    for a filter that modifies response headers. \n
   543                                    Support: Extended"
   544                                  properties:
   545                                    add:
   546                                      description: "Add adds the given header(s) (name,
   547                                        value) to the request before the action. It
   548                                        appends to any existing values associated
   549                                        with the header name. \n Input: GET /foo HTTP/1.1
   550                                        my-header: foo \n Config: add: - name: \"my-header\"
   551                                        value: \"bar,baz\" \n Output: GET /foo HTTP/1.1
   552                                        my-header: foo,bar,baz"
   553                                      items:
   554                                        description: HTTPHeader represents an HTTP
   555                                          Header name and value as defined by RFC
   556                                          7230.
   557                                        properties:
   558                                          name:
   559                                            description: "Name is the name of the
   560                                              HTTP Header to be matched. Name matching
   561                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   562                                              \n If multiple entries specify equivalent
   563                                              header names, the first entry with an
   564                                              equivalent name MUST be considered for
   565                                              a match. Subsequent entries with an
   566                                              equivalent header name MUST be ignored.
   567                                              Due to the case-insensitivity of header
   568                                              names, \"foo\" and \"Foo\" are considered
   569                                              equivalent."
   570                                            maxLength: 256
   571                                            minLength: 1
   572                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   573                                            type: string
   574                                          value:
   575                                            description: Value is the value of HTTP
   576                                              Header to be matched.
   577                                            maxLength: 4096
   578                                            minLength: 1
   579                                            type: string
   580                                        required:
   581                                        - name
   582                                        - value
   583                                        type: object
   584                                      maxItems: 16
   585                                      type: array
   586                                      x-kubernetes-list-map-keys:
   587                                      - name
   588                                      x-kubernetes-list-type: map
   589                                    remove:
   590                                      description: "Remove the given header(s) from
   591                                        the HTTP request before the action. The value
   592                                        of Remove is a list of HTTP header names.
   593                                        Note that the header names are case-insensitive
   594                                        (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   595                                        \n Input: GET /foo HTTP/1.1 my-header1: foo
   596                                        my-header2: bar my-header3: baz \n Config:
   597                                        remove: [\"my-header1\", \"my-header3\"] \n
   598                                        Output: GET /foo HTTP/1.1 my-header2: bar"
   599                                      items:
   600                                        type: string
   601                                      maxItems: 16
   602                                      type: array
   603                                    set:
   604                                      description: "Set overwrites the request with
   605                                        the given header (name, value) before the
   606                                        action. \n Input: GET /foo HTTP/1.1 my-header:
   607                                        foo \n Config: set: - name: \"my-header\"
   608                                        value: \"bar\" \n Output: GET /foo HTTP/1.1
   609                                        my-header: bar"
   610                                      items:
   611                                        description: HTTPHeader represents an HTTP
   612                                          Header name and value as defined by RFC
   613                                          7230.
   614                                        properties:
   615                                          name:
   616                                            description: "Name is the name of the
   617                                              HTTP Header to be matched. Name matching
   618                                              MUST be case insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   619                                              \n If multiple entries specify equivalent
   620                                              header names, the first entry with an
   621                                              equivalent name MUST be considered for
   622                                              a match. Subsequent entries with an
   623                                              equivalent header name MUST be ignored.
   624                                              Due to the case-insensitivity of header
   625                                              names, \"foo\" and \"Foo\" are considered
   626                                              equivalent."
   627                                            maxLength: 256
   628                                            minLength: 1
   629                                            pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   630                                            type: string
   631                                          value:
   632                                            description: Value is the value of HTTP
   633                                              Header to be matched.
   634                                            maxLength: 4096
   635                                            minLength: 1
   636                                            type: string
   637                                        required:
   638                                        - name
   639                                        - value
   640                                        type: object
   641                                      maxItems: 16
   642                                      type: array
   643                                      x-kubernetes-list-map-keys:
   644                                      - name
   645                                      x-kubernetes-list-type: map
   646                                  type: object
   647                                type:
   648                                  description: "Type identifies the type of filter
   649                                    to apply. As with other API fields, types are
   650                                    classified into three conformance levels: \n -
   651                                    Core: Filter types and their corresponding configuration
   652                                    defined by \"Support: Core\" in this package,
   653                                    e.g. \"RequestHeaderModifier\". All implementations
   654                                    supporting GRPCRoute MUST support core filters.
   655                                    \n - Extended: Filter types and their corresponding
   656                                    configuration defined by \"Support: Extended\"
   657                                    in this package, e.g. \"RequestMirror\". Implementers
   658                                    are encouraged to support extended filters. \n
   659                                    - Implementation-specific: Filters that are defined
   660                                    and supported by specific vendors. In the future,
   661                                    filters showing convergence in behavior across
   662                                    multiple implementations will be considered for
   663                                    inclusion in extended or core conformance levels.
   664                                    Filter-specific configuration for such filters
   665                                    is specified using the ExtensionRef field. `Type`
   666                                    MUST be set to \"ExtensionRef\" for custom filters.
   667                                    \n Implementers are encouraged to define custom
   668                                    implementation types to extend the core API with
   669                                    implementation-specific behavior. \n If a reference
   670                                    to a custom filter type cannot be resolved, the
   671                                    filter MUST NOT be skipped. Instead, requests
   672                                    that would have been processed by that filter
   673                                    MUST receive a HTTP error response. \n "
   674                                  enum:
   675                                  - ResponseHeaderModifier
   676                                  - RequestHeaderModifier
   677                                  - RequestMirror
   678                                  - ExtensionRef
   679                                  type: string
   680                              required:
   681                              - type
   682                              type: object
   683                            maxItems: 16
   684                            type: array
   685                          group:
   686                            default: ""
   687                            description: Group is the group of the referent. For example,
   688                              "gateway.networking.k8s.io". When unspecified or empty
   689                              string, core API group is inferred.
   690                            maxLength: 253
   691                            pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   692                            type: string
   693                          kind:
   694                            default: Service
   695                            description: "Kind is the Kubernetes resource kind of
   696                              the referent. For example \"Service\". \n Defaults to
   697                              \"Service\" when not specified. \n ExternalName services
   698                              can refer to CNAME DNS records that may live outside
   699                              of the cluster and as such are difficult to reason about
   700                              in terms of conformance. They also may not be safe to
   701                              forward to (see CVE-2021-25740 for more information).
   702                              Implementations SHOULD NOT support ExternalName Services.
   703                              \n Support: Core (Services with a type other than ExternalName)
   704                              \n Support: Implementation-specific (Services with type
   705                              ExternalName)"
   706                            maxLength: 63
   707                            minLength: 1
   708                            pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   709                            type: string
   710                          name:
   711                            description: Name is the name of the referent.
   712                            maxLength: 253
   713                            minLength: 1
   714                            type: string
   715                          namespace:
   716                            description: "Namespace is the namespace of the backend.
   717                              When unspecified, the local namespace is inferred. \n
   718                              Note that when a namespace different than the local
   719                              namespace is specified, a ReferenceGrant object is required
   720                              in the referent namespace to allow that namespace's
   721                              owner to accept the reference. See the ReferenceGrant
   722                              documentation for details. \n Support: Core"
   723                            maxLength: 63
   724                            minLength: 1
   725                            pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   726                            type: string
   727                          port:
   728                            description: Port specifies the destination port number
   729                              to use for this resource. Port is required when the
   730                              referent is a Kubernetes Service. In this case, the
   731                              port number is the service port number, not the target
   732                              port. For other resources, destination port might be
   733                              derived from the referent resource or this field.
   734                            format: int32
   735                            maximum: 65535
   736                            minimum: 1
   737                            type: integer
   738                          weight:
   739                            default: 1
   740                            description: "Weight specifies the proportion of requests
   741                              forwarded to the referenced backend. This is computed
   742                              as weight/(sum of all weights in this BackendRefs list).
   743                              For non-zero values, there may be some epsilon from
   744                              the exact proportion defined here depending on the precision
   745                              an implementation supports. Weight is not a percentage
   746                              and the sum of weights does not need to equal 100. \n
   747                              If only one backend is specified and it has a weight
   748                              greater than 0, 100% of the traffic is forwarded to
   749                              that backend. If weight is set to 0, no traffic should
   750                              be forwarded for this entry. If unspecified, weight
   751                              defaults to 1. \n Support for this field varies based
   752                              on the context where used."
   753                            format: int32
   754                            maximum: 1000000
   755                            minimum: 0
   756                            type: integer
   757                        required:
   758                        - name
   759                        type: object
   760                      maxItems: 16
   761                      type: array
   762                    filters:
   763                      description: "Filters define the filters that are applied to
   764                        requests that match this rule. \n The effects of ordering
   765                        of multiple behaviors are currently unspecified. This can
   766                        change in the future based on feedback during the alpha stage.
   767                        \n Conformance-levels at this level are defined based on the
   768                        type of filter: \n - ALL core filters MUST be supported by
   769                        all implementations that support GRPCRoute. - Implementers
   770                        are encouraged to support extended filters. - Implementation-specific
   771                        custom filters have no API guarantees across implementations.
   772                        \n Specifying a core filter multiple times has unspecified
   773                        or implementation-specific conformance. Support: Core"
   774                      items:
   775                        description: GRPCRouteFilter defines processing steps that
   776                          must be completed during the request or response lifecycle.
   777                          GRPCRouteFilters are meant as an extension point to express
   778                          processing that may be done in Gateway implementations.
   779                          Some examples include request or response modification,
   780                          implementing authentication strategies, rate-limiting, and
   781                          traffic shaping. API guarantee/conformance is defined based
   782                          on the type of the filter.
   783                        properties:
   784                          extensionRef:
   785                            description: "ExtensionRef is an optional, implementation-specific
   786                              extension to the \"filter\" behavior.  For example,
   787                              resource \"myroutefilter\" in group \"networking.example.net\").
   788                              ExtensionRef MUST NOT be used for core and extended
   789                              filters. \n Support: Implementation-specific"
   790                            properties:
   791                              group:
   792                                description: Group is the group of the referent. For
   793                                  example, "gateway.networking.k8s.io". When unspecified
   794                                  or empty string, core API group is inferred.
   795                                maxLength: 253
   796                                pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   797                                type: string
   798                              kind:
   799                                description: Kind is kind of the referent. For example
   800                                  "HTTPRoute" or "Service".
   801                                maxLength: 63
   802                                minLength: 1
   803                                pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   804                                type: string
   805                              name:
   806                                description: Name is the name of the referent.
   807                                maxLength: 253
   808                                minLength: 1
   809                                type: string
   810                            required:
   811                            - group
   812                            - kind
   813                            - name
   814                            type: object
   815                          requestHeaderModifier:
   816                            description: "RequestHeaderModifier defines a schema for
   817                              a filter that modifies request headers. \n Support:
   818                              Core"
   819                            properties:
   820                              add:
   821                                description: "Add adds the given header(s) (name,
   822                                  value) to the request before the action. It appends
   823                                  to any existing values associated with the header
   824                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
   825                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
   826                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
   827                                items:
   828                                  description: HTTPHeader represents an HTTP Header
   829                                    name and value as defined by RFC 7230.
   830                                  properties:
   831                                    name:
   832                                      description: "Name is the name of the HTTP Header
   833                                        to be matched. Name matching MUST be case
   834                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   835                                        \n If multiple entries specify equivalent
   836                                        header names, the first entry with an equivalent
   837                                        name MUST be considered for a match. Subsequent
   838                                        entries with an equivalent header name MUST
   839                                        be ignored. Due to the case-insensitivity
   840                                        of header names, \"foo\" and \"Foo\" are considered
   841                                        equivalent."
   842                                      maxLength: 256
   843                                      minLength: 1
   844                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   845                                      type: string
   846                                    value:
   847                                      description: Value is the value of HTTP Header
   848                                        to be matched.
   849                                      maxLength: 4096
   850                                      minLength: 1
   851                                      type: string
   852                                  required:
   853                                  - name
   854                                  - value
   855                                  type: object
   856                                maxItems: 16
   857                                type: array
   858                                x-kubernetes-list-map-keys:
   859                                - name
   860                                x-kubernetes-list-type: map
   861                              remove:
   862                                description: "Remove the given header(s) from the
   863                                  HTTP request before the action. The value of Remove
   864                                  is a list of HTTP header names. Note that the header
   865                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
   866                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
   867                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
   868                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
   869                                  bar"
   870                                items:
   871                                  type: string
   872                                maxItems: 16
   873                                type: array
   874                              set:
   875                                description: "Set overwrites the request with the
   876                                  given header (name, value) before the action. \n
   877                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
   878                                  set: - name: \"my-header\" value: \"bar\" \n Output:
   879                                  GET /foo HTTP/1.1 my-header: bar"
   880                                items:
   881                                  description: HTTPHeader represents an HTTP Header
   882                                    name and value as defined by RFC 7230.
   883                                  properties:
   884                                    name:
   885                                      description: "Name is the name of the HTTP Header
   886                                        to be matched. Name matching MUST be case
   887                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
   888                                        \n If multiple entries specify equivalent
   889                                        header names, the first entry with an equivalent
   890                                        name MUST be considered for a match. Subsequent
   891                                        entries with an equivalent header name MUST
   892                                        be ignored. Due to the case-insensitivity
   893                                        of header names, \"foo\" and \"Foo\" are considered
   894                                        equivalent."
   895                                      maxLength: 256
   896                                      minLength: 1
   897                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
   898                                      type: string
   899                                    value:
   900                                      description: Value is the value of HTTP Header
   901                                        to be matched.
   902                                      maxLength: 4096
   903                                      minLength: 1
   904                                      type: string
   905                                  required:
   906                                  - name
   907                                  - value
   908                                  type: object
   909                                maxItems: 16
   910                                type: array
   911                                x-kubernetes-list-map-keys:
   912                                - name
   913                                x-kubernetes-list-type: map
   914                            type: object
   915                          requestMirror:
   916                            description: "RequestMirror defines a schema for a filter
   917                              that mirrors requests. Requests are sent to the specified
   918                              destination, but responses from that destination are
   919                              ignored. \n Support: Extended"
   920                            properties:
   921                              backendRef:
   922                                description: "BackendRef references a resource where
   923                                  mirrored requests are sent. \n If the referent cannot
   924                                  be found, this BackendRef is invalid and must be
   925                                  dropped from the Gateway. The controller must ensure
   926                                  the \"ResolvedRefs\" condition on the Route status
   927                                  is set to `status: False` and not configure this
   928                                  backend in the underlying implementation. \n If
   929                                  there is a cross-namespace reference to an *existing*
   930                                  object that is not allowed by a ReferenceGrant,
   931                                  the controller must ensure the \"ResolvedRefs\"
   932                                  \ condition on the Route is set to `status: False`,
   933                                  with the \"RefNotPermitted\" reason and not configure
   934                                  this backend in the underlying implementation. \n
   935                                  In either error case, the Message of the `ResolvedRefs`
   936                                  Condition should be used to provide more detail
   937                                  about the problem. \n Support: Extended for Kubernetes
   938                                  Service \n Support: Implementation-specific for
   939                                  any other resource"
   940                                properties:
   941                                  group:
   942                                    default: ""
   943                                    description: Group is the group of the referent.
   944                                      For example, "gateway.networking.k8s.io". When
   945                                      unspecified or empty string, core API group
   946                                      is inferred.
   947                                    maxLength: 253
   948                                    pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
   949                                    type: string
   950                                  kind:
   951                                    default: Service
   952                                    description: "Kind is the Kubernetes resource
   953                                      kind of the referent. For example \"Service\".
   954                                      \n Defaults to \"Service\" when not specified.
   955                                      \n ExternalName services can refer to CNAME
   956                                      DNS records that may live outside of the cluster
   957                                      and as such are difficult to reason about in
   958                                      terms of conformance. They also may not be safe
   959                                      to forward to (see CVE-2021-25740 for more information).
   960                                      Implementations SHOULD NOT support ExternalName
   961                                      Services. \n Support: Core (Services with a
   962                                      type other than ExternalName) \n Support: Implementation-specific
   963                                      (Services with type ExternalName)"
   964                                    maxLength: 63
   965                                    minLength: 1
   966                                    pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
   967                                    type: string
   968                                  name:
   969                                    description: Name is the name of the referent.
   970                                    maxLength: 253
   971                                    minLength: 1
   972                                    type: string
   973                                  namespace:
   974                                    description: "Namespace is the namespace of the
   975                                      backend. When unspecified, the local namespace
   976                                      is inferred. \n Note that when a namespace different
   977                                      than the local namespace is specified, a ReferenceGrant
   978                                      object is required in the referent namespace
   979                                      to allow that namespace's owner to accept the
   980                                      reference. See the ReferenceGrant documentation
   981                                      for details. \n Support: Core"
   982                                    maxLength: 63
   983                                    minLength: 1
   984                                    pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
   985                                    type: string
   986                                  port:
   987                                    description: Port specifies the destination port
   988                                      number to use for this resource. Port is required
   989                                      when the referent is a Kubernetes Service. In
   990                                      this case, the port number is the service port
   991                                      number, not the target port. For other resources,
   992                                      destination port might be derived from the referent
   993                                      resource or this field.
   994                                    format: int32
   995                                    maximum: 65535
   996                                    minimum: 1
   997                                    type: integer
   998                                required:
   999                                - name
  1000                                type: object
  1001                            required:
  1002                            - backendRef
  1003                            type: object
  1004                          responseHeaderModifier:
  1005                            description: "ResponseHeaderModifier defines a schema
  1006                              for a filter that modifies response headers. \n Support:
  1007                              Extended"
  1008                            properties:
  1009                              add:
  1010                                description: "Add adds the given header(s) (name,
  1011                                  value) to the request before the action. It appends
  1012                                  to any existing values associated with the header
  1013                                  name. \n Input: GET /foo HTTP/1.1 my-header: foo
  1014                                  \n Config: add: - name: \"my-header\" value: \"bar,baz\"
  1015                                  \n Output: GET /foo HTTP/1.1 my-header: foo,bar,baz"
  1016                                items:
  1017                                  description: HTTPHeader represents an HTTP Header
  1018                                    name and value as defined by RFC 7230.
  1019                                  properties:
  1020                                    name:
  1021                                      description: "Name is the name of the HTTP Header
  1022                                        to be matched. Name matching MUST be case
  1023                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1024                                        \n If multiple entries specify equivalent
  1025                                        header names, the first entry with an equivalent
  1026                                        name MUST be considered for a match. Subsequent
  1027                                        entries with an equivalent header name MUST
  1028                                        be ignored. Due to the case-insensitivity
  1029                                        of header names, \"foo\" and \"Foo\" are considered
  1030                                        equivalent."
  1031                                      maxLength: 256
  1032                                      minLength: 1
  1033                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1034                                      type: string
  1035                                    value:
  1036                                      description: Value is the value of HTTP Header
  1037                                        to be matched.
  1038                                      maxLength: 4096
  1039                                      minLength: 1
  1040                                      type: string
  1041                                  required:
  1042                                  - name
  1043                                  - value
  1044                                  type: object
  1045                                maxItems: 16
  1046                                type: array
  1047                                x-kubernetes-list-map-keys:
  1048                                - name
  1049                                x-kubernetes-list-type: map
  1050                              remove:
  1051                                description: "Remove the given header(s) from the
  1052                                  HTTP request before the action. The value of Remove
  1053                                  is a list of HTTP header names. Note that the header
  1054                                  names are case-insensitive (see https://datatracker.ietf.org/doc/html/rfc2616#section-4.2).
  1055                                  \n Input: GET /foo HTTP/1.1 my-header1: foo my-header2:
  1056                                  bar my-header3: baz \n Config: remove: [\"my-header1\",
  1057                                  \"my-header3\"] \n Output: GET /foo HTTP/1.1 my-header2:
  1058                                  bar"
  1059                                items:
  1060                                  type: string
  1061                                maxItems: 16
  1062                                type: array
  1063                              set:
  1064                                description: "Set overwrites the request with the
  1065                                  given header (name, value) before the action. \n
  1066                                  Input: GET /foo HTTP/1.1 my-header: foo \n Config:
  1067                                  set: - name: \"my-header\" value: \"bar\" \n Output:
  1068                                  GET /foo HTTP/1.1 my-header: bar"
  1069                                items:
  1070                                  description: HTTPHeader represents an HTTP Header
  1071                                    name and value as defined by RFC 7230.
  1072                                  properties:
  1073                                    name:
  1074                                      description: "Name is the name of the HTTP Header
  1075                                        to be matched. Name matching MUST be case
  1076                                        insensitive. (See https://tools.ietf.org/html/rfc7230#section-3.2).
  1077                                        \n If multiple entries specify equivalent
  1078                                        header names, the first entry with an equivalent
  1079                                        name MUST be considered for a match. Subsequent
  1080                                        entries with an equivalent header name MUST
  1081                                        be ignored. Due to the case-insensitivity
  1082                                        of header names, \"foo\" and \"Foo\" are considered
  1083                                        equivalent."
  1084                                      maxLength: 256
  1085                                      minLength: 1
  1086                                      pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1087                                      type: string
  1088                                    value:
  1089                                      description: Value is the value of HTTP Header
  1090                                        to be matched.
  1091                                      maxLength: 4096
  1092                                      minLength: 1
  1093                                      type: string
  1094                                  required:
  1095                                  - name
  1096                                  - value
  1097                                  type: object
  1098                                maxItems: 16
  1099                                type: array
  1100                                x-kubernetes-list-map-keys:
  1101                                - name
  1102                                x-kubernetes-list-type: map
  1103                            type: object
  1104                          type:
  1105                            description: "Type identifies the type of filter to apply.
  1106                              As with other API fields, types are classified into
  1107                              three conformance levels: \n - Core: Filter types and
  1108                              their corresponding configuration defined by \"Support:
  1109                              Core\" in this package, e.g. \"RequestHeaderModifier\".
  1110                              All implementations supporting GRPCRoute MUST support
  1111                              core filters. \n - Extended: Filter types and their
  1112                              corresponding configuration defined by \"Support: Extended\"
  1113                              in this package, e.g. \"RequestMirror\". Implementers
  1114                              are encouraged to support extended filters. \n - Implementation-specific:
  1115                              Filters that are defined and supported by specific vendors.
  1116                              In the future, filters showing convergence in behavior
  1117                              across multiple implementations will be considered for
  1118                              inclusion in extended or core conformance levels. Filter-specific
  1119                              configuration for such filters is specified using the
  1120                              ExtensionRef field. `Type` MUST be set to \"ExtensionRef\"
  1121                              for custom filters. \n Implementers are encouraged to
  1122                              define custom implementation types to extend the core
  1123                              API with implementation-specific behavior. \n If a reference
  1124                              to a custom filter type cannot be resolved, the filter
  1125                              MUST NOT be skipped. Instead, requests that would have
  1126                              been processed by that filter MUST receive a HTTP error
  1127                              response. \n "
  1128                            enum:
  1129                            - ResponseHeaderModifier
  1130                            - RequestHeaderModifier
  1131                            - RequestMirror
  1132                            - ExtensionRef
  1133                            type: string
  1134                        required:
  1135                        - type
  1136                        type: object
  1137                      maxItems: 16
  1138                      type: array
  1139                    matches:
  1140                      description: "Matches define conditions used for matching the
  1141                        rule against incoming gRPC requests. Each match is independent,
  1142                        i.e. this rule will be matched if **any** one of the matches
  1143                        is satisfied. \n For example, take the following matches configuration:
  1144                        \n ``` matches: - method: service: foo.bar headers: values:
  1145                        version: 2 - method: service: foo.bar.v2 ``` \n For a request
  1146                        to match against this rule, it MUST satisfy EITHER of the
  1147                        two conditions: \n - service of foo.bar AND contains the header
  1148                        `version: 2` - service of foo.bar.v2 \n See the documentation
  1149                        for GRPCRouteMatch on how to specify multiple match conditions
  1150                        to be ANDed together. \n If no matches are specified, the
  1151                        implementation MUST match every gRPC request. \n Proxy or
  1152                        Load Balancer routing configuration generated from GRPCRoutes
  1153                        MUST prioritize rules based on the following criteria, continuing
  1154                        on ties. Merging MUST not be done between GRPCRoutes and HTTPRoutes.
  1155                        Precedence MUST be given to the rule with the largest number
  1156                        of: \n * Characters in a matching non-wildcard hostname. *
  1157                        Characters in a matching hostname. * Characters in a matching
  1158                        service. * Characters in a matching method. * Header matches.
  1159                        \n If ties still exist across multiple Routes, matching precedence
  1160                        MUST be determined in order of the following criteria, continuing
  1161                        on ties: \n * The oldest Route based on creation timestamp.
  1162                        * The Route appearing first in alphabetical order by \"{namespace}/{name}\".
  1163                        \n If ties still exist within the Route that has been given
  1164                        precedence, matching precedence MUST be granted to the first
  1165                        matching rule meeting the above criteria."
  1166                      items:
  1167                        description: "GRPCRouteMatch defines the predicate used to
  1168                          match requests to a given action. Multiple match types are
  1169                          ANDed together, i.e. the match will evaluate to true only
  1170                          if all conditions are satisfied. \n For example, the match
  1171                          below will match a gRPC request only if its service is `foo`
  1172                          AND it contains the `version: v1` header: \n ``` matches:
  1173                          - method: type: Exact service: \"foo\" headers: - name:
  1174                          \"version\" value \"v1\" \n ```"
  1175                        properties:
  1176                          headers:
  1177                            description: Headers specifies gRPC request header matchers.
  1178                              Multiple match values are ANDed together, meaning, a
  1179                              request MUST match all the specified headers to select
  1180                              the route.
  1181                            items:
  1182                              description: GRPCHeaderMatch describes how to select
  1183                                a gRPC route by matching gRPC request headers.
  1184                              properties:
  1185                                name:
  1186                                  description: "Name is the name of the gRPC Header
  1187                                    to be matched. \n If multiple entries specify
  1188                                    equivalent header names, only the first entry
  1189                                    with an equivalent name MUST be considered for
  1190                                    a match. Subsequent entries with an equivalent
  1191                                    header name MUST be ignored. Due to the case-insensitivity
  1192                                    of header names, \"foo\" and \"Foo\" are considered
  1193                                    equivalent."
  1194                                  maxLength: 256
  1195                                  minLength: 1
  1196                                  pattern: ^[A-Za-z0-9!#$%&'*+\-.^_\x60|~]+$
  1197                                  type: string
  1198                                type:
  1199                                  default: Exact
  1200                                  description: Type specifies how to match against
  1201                                    the value of the header.
  1202                                  enum:
  1203                                  - Exact
  1204                                  - RegularExpression
  1205                                  type: string
  1206                                value:
  1207                                  description: Value is the value of the gRPC Header
  1208                                    to be matched.
  1209                                  maxLength: 4096
  1210                                  minLength: 1
  1211                                  type: string
  1212                              required:
  1213                              - name
  1214                              - value
  1215                              type: object
  1216                            maxItems: 16
  1217                            type: array
  1218                            x-kubernetes-list-map-keys:
  1219                            - name
  1220                            x-kubernetes-list-type: map
  1221                          method:
  1222                            description: Method specifies a gRPC request service/method
  1223                              matcher. If this field is not specified, all services
  1224                              and methods will match.
  1225                            properties:
  1226                              method:
  1227                                description: "Value of the method to match against.
  1228                                  If left empty or omitted, will match all services.
  1229                                  \n At least one of Service and Method MUST be a
  1230                                  non-empty string."
  1231                                maxLength: 1024
  1232                                type: string
  1233                              service:
  1234                                description: "Value of the service to match against.
  1235                                  If left empty or omitted, will match any service.
  1236                                  \n At least one of Service and Method MUST be a
  1237                                  non-empty string."
  1238                                maxLength: 1024
  1239                                type: string
  1240                              type:
  1241                                default: Exact
  1242                                description: "Type specifies how to match against
  1243                                  the service and/or method. Support: Core (Exact
  1244                                  with service and method specified) \n Support: Implementation-specific
  1245                                  (Exact with method specified but no service specified)
  1246                                  \n Support: Implementation-specific (RegularExpression)"
  1247                                enum:
  1248                                - Exact
  1249                                - RegularExpression
  1250                                type: string
  1251                            type: object
  1252                        type: object
  1253                      maxItems: 8
  1254                      type: array
  1255                  type: object
  1256                maxItems: 16
  1257                type: array
  1258            type: object
  1259          status:
  1260            description: Status defines the current state of GRPCRoute.
  1261            properties:
  1262              parents:
  1263                description: "Parents is a list of parent resources (usually Gateways)
  1264                  that are associated with the route, and the status of the route
  1265                  with respect to each parent. When this route attaches to a parent,
  1266                  the controller that manages the parent must add an entry to this
  1267                  list when the controller first sees the route and should update
  1268                  the entry as appropriate when the route or gateway is modified.
  1269                  \n Note that parent references that cannot be resolved by an implementation
  1270                  of this API will not be added to this list. Implementations of this
  1271                  API can only populate Route status for the Gateways/parent resources
  1272                  they are responsible for. \n A maximum of 32 Gateways will be represented
  1273                  in this list. An empty list means the route has not been attached
  1274                  to any Gateway."
  1275                items:
  1276                  description: RouteParentStatus describes the status of a route with
  1277                    respect to an associated Parent.
  1278                  properties:
  1279                    conditions:
  1280                      description: "Conditions describes the status of the route with
  1281                        respect to the Gateway. Note that the route's availability
  1282                        is also subject to the Gateway's own status conditions and
  1283                        listener status. \n If the Route's ParentRef specifies an
  1284                        existing Gateway that supports Routes of this kind AND that
  1285                        Gateway's controller has sufficient access, then that Gateway's
  1286                        controller MUST set the \"Accepted\" condition on the Route,
  1287                        to indicate whether the route has been accepted or rejected
  1288                        by the Gateway, and why. \n A Route MUST be considered \"Accepted\"
  1289                        if at least one of the Route's rules is implemented by the
  1290                        Gateway. \n There are a number of cases where the \"Accepted\"
  1291                        condition may not be set due to lack of controller visibility,
  1292                        that includes when: \n * The Route refers to a non-existent
  1293                        parent. * The Route is of a type that the controller does
  1294                        not support. * The Route is in a namespace the controller
  1295                        does not have access to."
  1296                      items:
  1297                        description: "Condition contains details for one aspect of
  1298                          the current state of this API Resource. --- This struct
  1299                          is intended for direct use as an array at the field path
  1300                          .status.conditions.  For example, \n type FooStatus struct{
  1301                          // Represents the observations of a foo's current state.
  1302                          // Known .status.conditions.type are: \"Available\", \"Progressing\",
  1303                          and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge
  1304                          // +listType=map // +listMapKey=type Conditions []metav1.Condition
  1305                          `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\"
  1306                          protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields
  1307                          }"
  1308                        properties:
  1309                          lastTransitionTime:
  1310                            description: lastTransitionTime is the last time the condition
  1311                              transitioned from one status to another. This should
  1312                              be when the underlying condition changed.  If that is
  1313                              not known, then using the time when the API field changed
  1314                              is acceptable.
  1315                            format: date-time
  1316                            type: string
  1317                          message:
  1318                            description: message is a human readable message indicating
  1319                              details about the transition. This may be an empty string.
  1320                            maxLength: 32768
  1321                            type: string
  1322                          observedGeneration:
  1323                            description: observedGeneration represents the .metadata.generation
  1324                              that the condition was set based upon. For instance,
  1325                              if .metadata.generation is currently 12, but the .status.conditions[x].observedGeneration
  1326                              is 9, the condition is out of date with respect to the
  1327                              current state of the instance.
  1328                            format: int64
  1329                            minimum: 0
  1330                            type: integer
  1331                          reason:
  1332                            description: reason contains a programmatic identifier
  1333                              indicating the reason for the condition's last transition.
  1334                              Producers of specific condition types may define expected
  1335                              values and meanings for this field, and whether the
  1336                              values are considered a guaranteed API. The value should
  1337                              be a CamelCase string. This field may not be empty.
  1338                            maxLength: 1024
  1339                            minLength: 1
  1340                            pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
  1341                            type: string
  1342                          status:
  1343                            description: status of the condition, one of True, False,
  1344                              Unknown.
  1345                            enum:
  1346                            - "True"
  1347                            - "False"
  1348                            - Unknown
  1349                            type: string
  1350                          type:
  1351                            description: type of condition in CamelCase or in foo.example.com/CamelCase.
  1352                              --- Many .condition.type values are consistent across
  1353                              resources like Available, but because arbitrary conditions
  1354                              can be useful (see .node.status.conditions), the ability
  1355                              to deconflict is important. The regex it matches is
  1356                              (dns1123SubdomainFmt/)?(qualifiedNameFmt)
  1357                            maxLength: 316
  1358                            pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
  1359                            type: string
  1360                        required:
  1361                        - lastTransitionTime
  1362                        - message
  1363                        - reason
  1364                        - status
  1365                        - type
  1366                        type: object
  1367                      maxItems: 8
  1368                      minItems: 1
  1369                      type: array
  1370                      x-kubernetes-list-map-keys:
  1371                      - type
  1372                      x-kubernetes-list-type: map
  1373                    controllerName:
  1374                      description: "ControllerName is a domain/path string that indicates
  1375                        the name of the controller that wrote this status. This corresponds
  1376                        with the controllerName field on GatewayClass. \n Example:
  1377                        \"example.net/gateway-controller\". \n The format of this
  1378                        field is DOMAIN \"/\" PATH, where DOMAIN and PATH are valid
  1379                        Kubernetes names (https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names).
  1380                        \n Controllers MUST populate this field when writing status.
  1381                        Controllers should ensure that entries to status populated
  1382                        with their ControllerName are cleaned up when they are no
  1383                        longer necessary."
  1384                      maxLength: 253
  1385                      minLength: 1
  1386                      pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*\/[A-Za-z0-9\/\-._~%!$&'()*+,;=:]+$
  1387                      type: string
  1388                    parentRef:
  1389                      description: ParentRef corresponds with a ParentRef in the spec
  1390                        that this RouteParentStatus struct describes the status of.
  1391                      properties:
  1392                        group:
  1393                          default: gateway.networking.k8s.io
  1394                          description: "Group is the group of the referent. When unspecified,
  1395                            \"gateway.networking.k8s.io\" is inferred. To set the
  1396                            core API group (such as for a \"Service\" kind referent),
  1397                            Group must be explicitly set to \"\" (empty string). \n
  1398                            Support: Core"
  1399                          maxLength: 253
  1400                          pattern: ^$|^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1401                          type: string
  1402                        kind:
  1403                          default: Gateway
  1404                          description: "Kind is kind of the referent. \n Support:
  1405                            Core (Gateway) \n Support: Implementation-specific (Other
  1406                            Resources)"
  1407                          maxLength: 63
  1408                          minLength: 1
  1409                          pattern: ^[a-zA-Z]([-a-zA-Z0-9]*[a-zA-Z0-9])?$
  1410                          type: string
  1411                        name:
  1412                          description: "Name is the name of the referent. \n Support:
  1413                            Core"
  1414                          maxLength: 253
  1415                          minLength: 1
  1416                          type: string
  1417                        namespace:
  1418                          description: "Namespace is the namespace of the referent.
  1419                            When unspecified, this refers to the local namespace of
  1420                            the Route. \n Note that there are specific rules for ParentRefs
  1421                            which cross namespace boundaries. Cross-namespace references
  1422                            are only valid if they are explicitly allowed by something
  1423                            in the namespace they are referring to. For example: Gateway
  1424                            has the AllowedRoutes field, and ReferenceGrant provides
  1425                            a generic way to enable any other kind of cross-namespace
  1426                            reference. \n Support: Core"
  1427                          maxLength: 63
  1428                          minLength: 1
  1429                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$
  1430                          type: string
  1431                        port:
  1432                          description: "Port is the network port this Route targets.
  1433                            It can be interpreted differently based on the type of
  1434                            parent resource. \n When the parent resource is a Gateway,
  1435                            this targets all listeners listening on the specified
  1436                            port that also support this kind of Route(and select this
  1437                            Route). It's not recommended to set `Port` unless the
  1438                            networking behaviors specified in a Route must apply to
  1439                            a specific port as opposed to a listener(s) whose port(s)
  1440                            may be changed. When both Port and SectionName are specified,
  1441                            the name and port of the selected listener must match
  1442                            both specified values. \n Implementations MAY choose to
  1443                            support other parent resources. Implementations supporting
  1444                            other types of parent resources MUST clearly document
  1445                            how/if Port is interpreted. \n For the purpose of status,
  1446                            an attachment is considered successful as long as the
  1447                            parent resource accepts it partially. For example, Gateway
  1448                            listeners can restrict which Routes can attach to them
  1449                            by Route kind, namespace, or hostname. If 1 of 2 Gateway
  1450                            listeners accept attachment from the referencing Route,
  1451                            the Route MUST be considered successfully attached. If
  1452                            no Gateway listeners accept attachment from this Route,
  1453                            the Route MUST be considered detached from the Gateway.
  1454                            \n Support: Extended \n <gateway:experimental>"
  1455                          format: int32
  1456                          maximum: 65535
  1457                          minimum: 1
  1458                          type: integer
  1459                        sectionName:
  1460                          description: "SectionName is the name of a section within
  1461                            the target resource. In the following resources, SectionName
  1462                            is interpreted as the following: \n * Gateway: Listener
  1463                            Name. When both Port (experimental) and SectionName are
  1464                            specified, the name and port of the selected listener
  1465                            must match both specified values. \n Implementations MAY
  1466                            choose to support attaching Routes to other resources.
  1467                            If that is the case, they MUST clearly document how SectionName
  1468                            is interpreted. \n When unspecified (empty string), this
  1469                            will reference the entire resource. For the purpose of
  1470                            status, an attachment is considered successful if at least
  1471                            one section in the parent resource accepts it. For example,
  1472                            Gateway listeners can restrict which Routes can attach
  1473                            to them by Route kind, namespace, or hostname. If 1 of
  1474                            2 Gateway listeners accept attachment from the referencing
  1475                            Route, the Route MUST be considered successfully attached.
  1476                            If no Gateway listeners accept attachment from this Route,
  1477                            the Route MUST be considered detached from the Gateway.
  1478                            \n Support: Core"
  1479                          maxLength: 253
  1480                          minLength: 1
  1481                          pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
  1482                          type: string
  1483                      required:
  1484                      - name
  1485                      type: object
  1486                  required:
  1487                  - controllerName
  1488                  - parentRef
  1489                  type: object
  1490                maxItems: 32
  1491                type: array
  1492            required:
  1493            - parents
  1494            type: object
  1495        type: object
  1496    served: true
  1497    storage: true
  1498    subresources:
  1499      status: {}
  1500status:
  1501  acceptedNames:
  1502    kind: ""
  1503    plural: ""
  1504  conditions: null
  1505  storedVersions: null
  1506{{- end }}
  1507

View as plain text