cwielenb/CNCF-Dataset huggingface dataset:
Project: KubeBlocks by ApeCloud (App Definition and Development / Database)
File: add-ons-of-kubeblocks.md

title: Overview description: An overview of add an database add-on to KubeBlocks keywords: [add-on, integration] sidebar_position: 1 sidebar_label: Add-ons of KubeBlocks KubeBlocks is a control and management platform to manage a bunch of database engines and other add-ons. This series provides basic knowledge of add-ons, so you can get a quick start and become a member of the KubeBlocks community. KubeBlocks features a rich add-on ecosystem with major databases, streaming and vector databases, including: Relational Database: ApeCloud-MySQL (MySQL RaftGroup cluster), PostgreSQL (Replication cluster) NoSQL Database: MongoDB, Redis Graph Database: Nebula (from community contributors) Time Series Database: TDengine, Greptime (from community contributors) Vector Database: Milvus, Qdrant, Weaviate, etc. Streaming: Kafka, Pulsar Adding an add-on to KubeBlocks is easy, you can just follow this guide to add the add-on to KubeBlocks as long as you know the followings: How to write a YAML file (e.g., You should know how many spaces to add when indenting with YAML). Knowledge about Helm (e.g. What is Helm and Helm chart). Have tried K8s (e.g., You should know what a pod is, or have installed an operator on K8s with Helm). Grasp basic concepts of KubeBlocks, such as ClusterDefinition, ClusterVersion and Cluster. If you have any question, you can join our to ask.
Project: Beam (App Definition and Development / Streaming & Messaging)
File: orielresearch.md

title: "Oriel Research" icon: /images/logos/powered-by/orielresearch.png hasLink: "https://www.youtube.com/watch?v=KHC8FXgabHk" <!-- Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. -->
Project: Chef InSpec (Provisioning / Security & Compliance)
File: google_access_context_manager_access_policies.md

+++ title = "googleaccesscontextmanageraccess_policies resource" draft = false gh_repo = "inspec" platform = "gcp" [menu] [menu.inspec] title = "googleaccesscontextmanageraccess_policies" identifier = "inspec/resources/gcp/googleaccesscontextmanageraccesspolicies.md googleaccesscontextmanageraccesspolicies resource" parent = "inspec/resources/gcp" +++ A `googleaccesscontextmanageraccess_policies` is used to test a Google AccessPolicy resource ```ruby describe googleaccesscontextmanageraccesspolicies(orgid: '190694428152') do its('count') { should be >= 1 } its('titles') { should include 'policytitle' } end ``` Properties that can be accessed from the `googleaccesscontextmanageraccess_policies` resource: See the resource for more information. `names` : an array of `googleaccesscontextmanageraccess_policy` name `create_times` : an array of `googleaccesscontextmanageraccesspolicy` createtime `update_times` : an array of `googleaccesscontextmanageraccesspolicy` updatetime `parents` : an array of `googleaccesscontextmanageraccess_policy` parent `titles` : an array of `googleaccesscontextmanageraccess_policy` title This resource supports all of the above properties as filter criteria, which can be used with `where` as a block or a method.
Project: Meshery (Provisioning / Automation & Configuration)
File: v0.6.121.md

layout: release date: 2023-08-12 tag: v0.6.121 [Extension] Add Collaborator Extension Point @senali-d (#8323) Update logs.svg @ritiksaxena124 (#8448) [Performance profile]- fix label on new certificate upload @sudhanshutech (#8421) [bug] Fix cancelled ctx @theBeginner86 (#8453) [CI] Workflow update of meshkit error docs @suhail34 (#8451) Added new job to send emails on job failure @VaibhavMalik4187 (#8449) [CI] Workflow update of meshkit error docs @suhail34 (#8451) [Extension] Add Collaborator Extension Point @senali-d (#8323) Thank you to our contributors for making this release possible: @Chadha93, @MUzairS15, @VaibhavMalik4187, @l5io, @leecalcote, @ritiksaxena124, @senali-d, @sudhanshutech, @suhail34, @theBeginner86 and l5io
Project: ClickHouse (App Definition and Development / Database)
File: v21.7.10.4-stable.md

sidebar_position: 1 sidebar_label: 2022 Backported in : Use real tmp file instead of predefined "rows_sources" for vertical merges. This avoids generating garbage directories in tmp disks. (). Backported in : Fix PostgreSQL-style cast (`::` operator) with negative numbers. (). Backported in : Fix transformation of disjunctions chain to `IN` (controlled by settings `optimizeminequalitydisjunctionchainlength`) in distributed queries with settings `legacycolumnnameoftupleliteral = 0`. (). Backported in : Fixed possible ZooKeeper watches leak on background processing of distributed DDL queue. Closes . (). Backported in : Fix bug which can lead to error `Existing table metadata in ZooKeeper differs in sorting key expression.` after alter of `ReplicatedVersionedCollapsingMergeTree`. Fixes . (). Backported in : Fix `There is no subcolumn` error, while select from tables, which have `Nested` columns and scalar columns with dot in name and the same prefix as `Nested` (e.g. `n.id UInt32, n.arr1 Array(UInt64), n.arr2 Array(UInt64)`). (). Backported in : Fix the coredump in the creation of distributed tables, when the parameters passed in are wrong. (). Backported in : Fix benign race condition in ReplicatedMergeTreeQueue. Shouldn't be visible for user, but can lead to subtle bugs. (). Backported in : Fix reading of subcolumns from compact parts. (). Backported in : Fix higher-order array functions (`SIGSEGV` for `arrayCompact`/`ILLEGAL_COLUMN` for `arrayDifference`/`arrayCumSumNonNegative`) with consts. (). Add more checks for LC in native protocol. (). CHJIT custom memory manager (). Function dictGet default implementation for nulls (). Fix usage of nested columns with non-array columns with the same prefix (). Lower compiledexpressioncache_size to 128MB ().
Project: Chef Habitat (App Definition and Development / Application Definition & Image Build)
File: running_habitat_windows_containers.md

+++ title = "Running Chef Habitat Windows Containers" description = "Running Chef Habitat Windows Containers" gh_repo = "habitat" [menu] [menu.habitat] title = "Running Chef Habitat Windows Containers" identifier = "habitat/containers/running-habitat-windows-containers Windows Containers" parent = "habitat/containers" weight = 80 +++ Exported Windows images use `microsoft/windowsservercore` as their base. This is the equivalent of a minimal Windows Server 2016 Core install. So you should not expect non default features and roles to be enabled such as IIS or Active Directory. Consider using an `init` hook to install any features needed by your Chef Habitat service. The `microsoft/windowsservercore` image is approximately 5GB. Due to this large size, you can expect that the first time you run an exported Chef Habitat service, pulling down the image may take several minutes. This wait should only occur on the very first `docker run` of any Chef Habitat Windows service. Additionally, depending on the Windows host operating system, running the container may also take considerably longer than what one is accustomed to with Linux based containers. This startup time will be highly influenced by the container isolation mode described below. There are two types of Windows containers and each runs under a different level of kernel isolation. These containers, like their Linux counterparts, share the host's kernel. You can expect these containers to start pretty quickly and this is the default container type on Windows Server 2016 hosts. Windows Hyper-V containers run inside of a very minimal Hyper-V VM. As a result, they do not share the host's kernel and offer a higher level of security and isolation. The cost of this isolation is that it will take longer for the container to start - perhaps a noticeable delay. Also be aware that the VM is provisioned with a default 1 GB limit of memory. If your service requires more than a gigabyte of memory, you can use the `--memory` argument with `docker run` and pass a larger limit. ```bash docker run --memory 2GB -it core/mysql ``` On a Windows 10 host, Windows containers will always run inside of Hyper-V isolation. Kernel sharing Windows Server containers are only available on Windows Server 2016 hosts. On Windows Server 2016, Windows Server containers are the default container type but you can force `docker run` to use Hyper-V containers by setting the `--isolation` argument to `hyperv`. ```bash docker run --isolation hyperv -it core/mysql ``` A common container pattern is to forward the container port to a local port and then access the container application by accessing `localhost` on the forwarded port. With Windows containers, published ports cannot be accessed using `localhost`. You will instead need to use the IP address of the host or the IP of the individual container to access the application's endpoint.
Project: Meshery (Provisioning / Automation & Configuration)
File: 1.12.0.md

component: 1.12.0 integrations: consulmesh.meshery consulmesh_definition.json exportedservices.meshery exportedservices.meshery ingressgateway.meshery ingressgateway.meshery mesh.meshery mesh.meshery proxydefaults.meshery proxydefaults.meshery servicedefaults.meshery servicedefaults.meshery serviceintentions.meshery serviceintentions.meshery serviceresolver.meshery serviceresolver.meshery servicerouter.meshery servicerouter.meshery servicesplitter.meshery servicesplitter.meshery terminatinggateway.meshery terminatinggateway.meshery
Project: Druid (App Definition and Development / Database)
File: known-issues.md

id: known-issues title: SQL-based ingestion known issues sidebar_label: Known issues <!-- ~ Licensed to the Apache Software Foundation (ASF) under one ~ or more contributor license agreements. See the NOTICE file ~ distributed with this work for additional information ~ regarding copyright ownership. The ASF licenses this file ~ to you under the Apache License, Version 2.0 (the ~ "License"); you may not use this file except in compliance ~ with the License. You may obtain a copy of the License at ~ ~ http://www.apache.org/licenses/LICENSE-2.0 ~ ~ Unless required by applicable law or agreed to in writing, ~ software distributed under the License is distributed on an ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY ~ KIND, either express or implied. See the License for the ~ specific language governing permissions and limitations ~ under the License. --> :::info This page describes SQL-based batch ingestion using the extension, new in Druid 24.0. Refer to the table to determine which ingestion method is right for you. ::: Fault tolerance is partially implemented. Workers get relaunched when they are killed unexpectedly. The controller does not get relaunched if it is killed unexpectedly. Worker task stage outputs are stored in the working directory given by `druid.indexer.task.baseDir`. Stages that generate a large amount of output data may exhaust all available disk space. In this case, the query fails with an with a message including "No space left on device". `GROUPING SETS` are not implemented. Queries using these features return a error. The `INSERT` and `REPLACE` statements with column lists, like `INSERT INTO tbl (a, b, c) SELECT ...`, is not implemented. `INSERT ... SELECT` and `REPLACE ... SELECT` insert columns from the `SELECT` statement based on column name. This differs from SQL standard behavior, where columns are inserted based on position. `INSERT` and `REPLACE` do not support all options available in , including the `createBitmapIndex` and `multiValueHandling` properties, and the `indexSpec` property. The feature is not available. All columns and their types must be specified explicitly using the `signature` parameter of the . `EXTERN` with input sources that match large numbers of files may exhaust available memory on the controller task. `EXTERN` refers to external files. Use `FROM` to access `druid` input sources. The maximum number of elements in a window cannot exceed a value of 100,000. To avoid `leafOperators` in MSQ engine, window functions have an extra scan stage after the window stage for cases where native engine has a non-empty `leafOperator`.
Project: ClickHouse (App Definition and Development / Database)
File: min.md

slug: /en/sql-reference/aggregate-functions/reference/min sidebar_position: 2 title: min Aggregate function that calculates the minimum across a group of values. Example: ``` SELECT min(salary) FROM employees; ``` ``` SELECT department, min(salary) FROM employees GROUP BY department; ``` If you need non-aggregate function to choose a minimum of two values, see `least`: ``` SELECT least(a, b) FROM table; ```
Project: Chef InSpec (Provisioning / Security & Compliance)
File: google_compute_target_tcp_proxies.md

+++ title = "googlecomputetargettcpproxies resource" draft = false gh_repo = "inspec" platform = "gcp" [menu] [menu.inspec] title = "googlecomputetargettcpproxies" identifier = "inspec/resources/gcp/googlecomputetargettcpproxies.md googlecomputetargettcpproxies resource" parent = "inspec/resources/gcp" +++ A `googlecomputetargettcpproxies` is used to test a Google TargetTcpProxy resource This resource has beta fields available. To retrieve these fields, include `beta: true` in the constructor for the resource ```ruby describe googlecomputetargettcpproxies(project: 'chef-gcp-inspec') do its('names') { should include 'inspec-gcp-target-tcp-proxy' } its('proxy_headers') { should include 'NONE' } end ``` Properties that can be accessed from the `googlecomputetargettcpproxies` resource: See the resource for more information. `creation_timestamps` : an array of `googlecomputetargettcpproxy` creation_timestamp `descriptions` : an array of `googlecomputetargettcpproxy` description `ids` : an array of `googlecomputetargettcpproxy` id `names` : an array of `googlecomputetargettcpproxy` name `proxy_headers` : an array of `googlecomputetargettcpproxy` proxy_header `services` : an array of `googlecomputetargettcpproxy` service This resource supports all of the above properties as filter criteria, which can be used with `where` as a block or a method. Ensure the is enabled for the current project.
Project: Apache Hadoop (App Definition and Development / Database)
File: Overview.md

<! Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. See accompanying LICENSE file. --> Yarn Service framework provides first class support and APIs to host long running services natively in YARN. In a nutshell, it serves as a container orchestration platform for managing containerized services on YARN. It supports both docker container and traditional process based containers in YARN. The responsibility of this framework includes performing configuration resolutions and mounts, lifecycle management such as stop/start/delete the service, flexing service components up/down, rolling upgrades services on YARN, monitoring services' healthiness and readiness and more. The yarn-service framework primarily includes below components: A core framework (ApplicationMaster) running on YARN to serve as a container orchestrator, being responsible for all service lifecycle managements. A restful API-server for users to interact with YARN to deploy/manage their services via a simple JSON spec. A DNS server backed by YARN service registry to enable discovering services on YARN by the standard DNS lookup. YARN Service framework makes it easy to bring existing services onto YARN. It hides all the complex low-level details of application management and relieves users from forced into writing new code. Developers of new services do not have to worry about YARN internals and only need to focus on containerization of their service(s). Further, another huge win of this feature is that now you can enable both traditional batch processing jobs and long running services in a single platform! The benefits of combining these workloads are two-fold: Greatly simplify the cluster operations as you have only a single cluster to deal with. Making both batch jobs and services share a cluster can greatly improve resource utilization. `This feature is in alpha state` and so APIs, command lines are subject to change. We will continue to update the documents over time. shows a quick tutorial that walks you through simple steps to deploy a service on YARN. : Describes the internals of the framework and some features in YARN core to support running services on YARN. : The API doc for deploying/managing services on YARN. : Describes the service discovery mechanism on YARN. : Deep dives into the Registry DNS internals. : List some example service definitions (`Yarnfile`). : Describes how to configure the custom services on YARN. : Describes how to upgrade a YARN service which is an experimental feature.
Project: Meshery (Provisioning / Automation & Configuration)
File: mesheryctl-exp-components.md

layout: default title: mesheryctl-exp-components permalink: reference/mesheryctl/exp/components redirect_from: reference/mesheryctl/exp/components/ type: reference display-title: "false" language: en command: exp subcommand: components View list of components and detail of components View list of components and detailed information of a specific component <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl exp components [flags] </div> </pre> To view list of components <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl exp components list </div> </pre> To view a specific component <pre class='codeblock-pre'> <div class='codeblock'> mesheryctl exp components view [component-name] </div> </pre> <pre class='codeblock-pre'> <div class='codeblock'> -h, --help help for components </div> </pre> <pre class='codeblock-pre'> <div class='codeblock'> --config string path to config file (default "/home/runner/.meshery/config.yaml") -v, --verbose verbose output </div> </pre> Go back to , if you want to add content manually to the CLI documentation, please refer to the for guidance.
Project: Lagoon (App Definition and Development / Application Definition & Image Build)
File: python.md

The . Based on . 2.7 \(available for compatibility only, no longer officially supported\) - `uselagoon/python-2.7` 3.7 \(available for compatibility only, no longer officially supported\) - `uselagoon/python-3.7` 3.8 (Security Support until October 2024) - `uselagoon/python-3.8` 3.9 (Security Support until October 2025) - `uselagoon/python-3.9` 3.10 (Security Support until October 2026) - `uselagoon/python-3.10` 3.11 (Security Support until October 2027) - `uselagoon/python-3.11` 3.12 (Security Support until October 2028) - `uselagoon/python-3.12` !!! Tip We stop updating and publishing EOL Python images usually with the Lagoon release that comes after the officially communicated EOL date: . Previous published versions will remain available. The default exposed port of Python containers is port `8800`. Persistent storage is configurable in Lagoon, using the `lagoon.type: python-persistent`. See for more info Use the following labels in your `docker-compose.yml` file to configure it: `lagoon.persistent` = use this to define the path in the container to use as persistent storage - e.g. /app/files `lagoon.persistent.size` = this to tell Lagoon how much storage to assign this path If you have multiple services that share the same storage, use this `lagoon.persistent.name` = (optional) use this to tell Lagoon to use the storage defined in another named service ```yaml title="docker-compose.yml" python: build: context: . dockerfile: Dockerfile labels: lagoon.type: python-persistent lagoon.persistent: /app/files lagoon.persistent.size: 500Mi ports: "8800" volumes: files:/app/files ```
Project: kpt (Provisioning / Automation & Configuration)
File: 01-functions-specification.md

In order to enable functions to be developed in different toolchains and languages and be interoperable and backwards compatible, the kpt project created a standard for the inter-process communication between the orchestrator (i.e. kpt CLI) and functions. This standard was published as and donated to the CNCF as part of the Kubernetes SIG-CLI. Understanding this specification enables you to have a deeper understanding of how things work under the hood. It also enables to create your own toolchain for function development if you so desire. As an example, you can see the `ResourceList` containing resources in the `wordpress` package: ```shell $ kpt fn source wordpress | less ```