cwielenb/CNCF-Dataset huggingface dataset:
Project: ko (App Definition and Development / Application Definition & Image Build)
File: get-started.md

First, . `ko` depends on the authentication configured in your Docker config (typically `~/.docker/config.json`). If you can push an image with `docker push`, you are already authenticated for `ko`! Since `ko` doesn't require `docker`, `ko login` also provides a surface for logging in to a container image registry with a username and password, similar to . Additionally, even if auth is not configured in the Docker config, `ko` includes built-in support for authenticating to the following container registries using credentials configured in the environment: Google Container Registry and Artifact Registry, using or auth configured in `gcloud`. Amazon Elastic Container Registry, using Azure Container Registry, using GitHub Container Registry, using the `GITHUB_TOKEN` environment variable `ko` depends on an environment variable, `KODOCKERREPO`, to identify where it should push images that it builds. Typically this will be a remote registry, e.g.: `KODOCKERREPO=gcr.io/my-project`, or `KODOCKERREPO=ghcr.io/my-org/my-repo`, or `KODOCKERREPO=my-dockerhub-user` `ko build ./cmd/app` builds and pushes a container image, and prints the resulting image digest to stdout. In this example, `./cmd/app` must be a `package main` that defines `func main()`. ```plaintext $ ko build ./cmd/app ... registry.example.com/my-project/app-099ba5bcefdead87f92606265fb99ac0@sha256:6e398316742b7aa4a93161dce4a23bc5c545700b862b43347b941000b112ec3e ``` Note: Prior to v0.10, the command was called `ko publish` -- this is equivalent to `ko build`, and both commands will work and do the same thing. The executable binary that was built from `./cmd/app` is available in the image at `/ko-app/app` -- the binary name matches the base import path name -- and that binary is the image's entrypoint.
Project: Meshery (Provisioning / Automation & Configuration)
File: fonio.md

layout: integration title: Fonio subtitle: Collaborative and visual infrastructure as code for Fonio image: /assets/img/integrations/fonio/icons/color/fonio-color.svg permalink: extensibility/integrations/fonio docURL: https://docs.meshery.io/extensibility/integrations/fonio description: integrations-category: Observability and Analysis integrations-subcategory: Monitoring registrant: Artifact Hub components: featureList: [ "Manage AWS Elastic Load Balancers for a Kubernetes cluster.", "Provide high performance traffic serving that can scale to millions of requests per second.", "Supports IP address targeting mode for Network Load Balancers." ] howItWorks: "Collaborative Infrastructure as Code" howItWorksDetails: "Elastic Load Balancing (ELB) automatically distributes incoming application traffic across multiple targets and virtual appliances in one or more Availability Zones (AZs)." language: en list: include type: extensibility category: integrations
Project: YugabyteDB (App Definition and Development / Database)
File: cluster-aware-drivers.md

title: Cluster aware client drivers headerTitle: Cluster-aware client drivers linkTitle: Cluster-aware drivers headcontent: menu: preview: identifier: cluster-aware-drivers parent: going-beyond-sql weight: 450 rightNav: hideH3: true type: docs YugabyteDB's innovative approach to distributed database systems extends beyond its core architecture to include intelligent client drivers that are specifically designed to interact with distributed clusters. In this section, we will explore the features and benefits of YugabyteDB's cluster-aware , highlighting their significance in distributed application development. Applications typically connect to a multi-node system via a load balancer, which accepts the multiple connections from the client and distributes them across the different nodes in the system. This is also the case for an application connecting to a YugabyteDB cluster using a standard PostgreSQL driver. Although the load balancer hides the cluster from the application, neither the load balancer nor the application has any idea of the topology of the cluster - every time you add a node to the cluster, you need to update the load balancer configuration. The load balancer also adds a network hop for the application to talk to the cluster. Smart drivers simplify the process of connecting to and communicating with a database cluster by allowing applications to connect without the need for an external load balancer. When an application connects to a cluster using the smart driver, the driver makes an initial connection to a node specified in the connection string. The driver then fetches information about all the nodes in the universe using the `yb_servers()` function. This list is refreshed at regular intervals (the default is 5 minutes). Subsequently, the driver connects to the least-loaded node before returning the connection to the application. Now that the driver has fetched information about all the nodes in the cluster, if load balancing is enabled via the connection string option `load_balance=true`, the driver distributes new connection requests made by the application across the different nodes in the cluster. In addition, because the application connects directly to the node, there is no extra hop.
Project: Kui (App Definition and Development / Application Definition & Image Build)
File: kui_shell_core.ExecType.md

/ / ExecType .ExecType "top-level", meaning the user hit enter in the CLI, "click-handler", meaning that the user clicked on a UI element "nested", meaning that some evaluator uses the repl in its internal implementation ClickHandler = `1` Nested = `2` Rerun = `3` TopLevel = `0`
Project: KICS (Provisioning / Security & Compliance)
File: 4d9f44c6-2f4a-4317-9bb5-267adbea0232.md

title: Cgroup Not Default hide: toc: true navigation: true <style> .highlight .hll { background-color: #ff171742; } .md-content { max-width: 1100px; margin: 0 auto; } </style> Query id: 4d9f44c6-2f4a-4317-9bb5-267adbea0232 Query name: Cgroup Not Default Platform: DockerCompose Severity: <span style="color:#ff7213">Medium</span> Category: Build Process URL: Control groups restrict the access processes and containers have to system resources such as CPU, RAM, IOPS and network. Not having a cgroup well configured may prove to be a security fault.<br> ```yaml title="Positive test num. 1 - yaml file" hl_lines="9" version: '2' services: iperfclient: build: context: . dockerfile: client.Dockerfile container_name: ipc cgroup_parent: nat-docker volumes: ./host:container.yaml networks: netnet expose: 1234 networks: netnet: ``` ```yaml title="Negative test num. 1 - yaml file" version: '2' services: iperfclient: build: context: . dockerfile: client.Dockerfile container_name: ipc volumes: ./host:container.yaml networks: netnet expose: 1234 networks: netnet: ```
Project: Beam (App Definition and Development / Streaming & Messaging)
File: 05_basic_ptransforms.md

Prompt: What is a PTransform in Apache Beam? Response: A (or transform) represents a data processing operation, or a step, in a Beam pipeline. A transform is applied to zero or more `PCollection` objects and produces zero or more `PCollection` objects. Transforms have the following key characteristics: Versatility: Able to execute a diverse range of operations on `PCollection` objects. Composability: Can be combined to form elaborate data processing pipelines. Parallel execution: Designed for distributed processing, allowing simultaneous execution across multiple workers. Scalability: Able to handle extensive data and suitable for both batch and streaming data. The Beam SDKs contain different transforms that you can apply to your pipelines `PCollection` objects. The following list includes common transform types: such as `TextIO.Read` and `Create`. A source transform conceptually has no input. such as `ParDo`, `GroupByKey`, `CoGroupByKey`, `Combine`, and `Count`. such as `TextIO.Write`. User-defined, application-specific . Transform processing logic is provided in the form of a function object, colloquially referred to as user code. This code is applied to each element of the input `PCollection` (or more than one `PCollection`). The `PCollection` objects can be linked together to create complex data processing sequences. User code for transforms must satisfy the . The following example shows how to apply custom user code to a `PCollection` using the `ParDo` transform: ```python import apache_beam as beam def SomeUserCode(element): return element with beam.Pipeline() as pipeline: input_collection = pipeline | beam.Create([...]) outputcollection = inputcollection | beam.ParDo(SomeUserCode()) ```
Project: YugabyteDB (App Definition and Development / Database)
File: dml_delete.md

title: DELETE statement [YSQL] headerTitle: DELETE linkTitle: DELETE description: Use the DELETE statement to remove rows that meet certain conditions, and when conditions are not provided in WHERE clause, all rows are deleted. menu: v2.18: identifier: dml_delete parent: statements type: docs Use the `DELETE` statement to remove rows that meet certain conditions, and when conditions are not provided in WHERE clause, all rows are deleted. `DELETE` outputs the number of rows that are being deleted. {{%ebnf%}} delete, returning_clause {{%/ebnf%}} See the section for more information about the semantics of the `commontableexpression` grammar rule. `USING` clause is not yet supported. While the `WHERE` clause allows a wide range of operators, the exact conditions used in the `WHERE` clause have significant performance considerations (especially for large datasets). For the best performance, use a `WHERE` clause that provides values for all columns in `PRIMARY KEY` or `INDEX KEY`. Specify the subqueries that are referenced by name in the DELETE statement. Specify the name of the table to be deleted. Specify the identifier of the target table within the DELETE statement. When an alias is specified, it must be used in place of the actual table in the statement. Specify the value to be returned. When the outputexpression_ references a column, the existing value of this column (deleted value) is used to returned. Create a sample table, insert a few rows, then delete one of the inserted row. ```plpgsql CREATE TABLE sample(k1 int, k2 int, v1 int, v2 text, PRIMARY KEY (k1, k2)); ``` ```plpgsql INSERT INTO sample VALUES (1, 2.0, 3, 'a'), (2, 3.0, 4, 'b'), (3, 4.0, 5, 'c'); ``` ```plpgsql yugabyte=# SELECT * FROM sample ORDER BY k1; ``` ``` k1 | k2 | v1 | v2 -+-+-+- 1 | 2 | 3 | a 2 | 3 | 4 | b 3 | 4 | 5 | c (3 rows) ``` ```plpgsql DELETE FROM sample WHERE k1 = 2 AND k2 = 3; ``` ```plpgsql yugabyte=# SELECT * FROM sample ORDER BY k1; ``` ``` DELETE 1 ``` ``` k1 | k2 | v1 | v2 -+-+-+- 1 | 2 | 3 | a 3 | 4 | 5 | c (2 rows) ```
Project: Chef InSpec (Provisioning / Security & Compliance)
File: azurerm_sql_servers.md

+++ title = "azurermsqlservers resource" draft = false gh_repo = "inspec" platform = "azure" [menu] [menu.inspec] title = "azurermsqlservers" identifier = "inspec/resources/azure/azurermsqlservers.md azurermsqlservers resource" parent = "inspec/resources/azure" +++ {{< inspec/azurermdeprecated resource="azuresql_servers" >}} Use the `azurermsqlservers` InSpec audit resource to test properties and configuration of Azure SQL Servers. This resource interacts with version `2018-06-01-preview` of the Azure Management API. For more information see the . At the moment, there doesn't appear to be a way to select the version of the Azure API docs. If you notice a newer version being referenced in the official documentation please open an issue or submit a pull request using the updated version. This resource is available in the `inspec-azure` [resource pack](/inspec/glossary/#resource-pack). To use it, add the following to your `inspec.yml` in your top-level profile: depends: name: inspec-azure git: https://github.com/inspec/inspec-azure.git You'll also need to setup your Azure credentials; see the resource pack . This resource first became available in 1.2.0 of the inspec-azure resource pack. An `azurermsqlservers` resource block returns all Azure SQL Servers, either within a Resource Group (if provided), or within an entire Subscription. describe azurermsqlservers do ... end or describe azurermsqlservers(resource_group: 'my-rg') do ... end The following examples show how to use this InSpec audit resource. describe azurermsqlservers do it { should exist } its('names') { should include 'my-server-name' } end Filters the results to include only those servers which match the given name. This is a string value. describe azurermsqlservers.where{ name.eql?('production-server-5') } do it { should exist } end Filters the results to include only those servers which reside in a given location. This is a string value. describe azurermsqlservers.where{ location.eql?('eastus') } do it { should exist } end `id` `name` `kind` `location` `properties` `tags` `type` Azure resource ID. SQL Server name, e.g. `my-sql-server`. its('names') { should include 'my-sql-database' } Kind of sql server. This is metadata used for the Azure portal experience. Resource location, e.g. `eastus`. its('locations') { should_not include 'eastus' } A collection of additional configuration properties related to the SQL Server, e.g. `administratorLogin`. Resource tags applied to the SQL Server. The type of Resource, typically `Microsoft.Sql/servers`. {{< readfile file="content/inspec/reusable/md/inspecmatcherslink.md" >}} This resource has the following special matchers. The control will pass if the filter returns at least one result. Use `should_not` if you expect zero matches. describe azurermsqlservers do it { should exist } end Your [Service Principal](https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-create-service-principal-portal) must be setup with a `contributor` role on the subscription you wish to test.
Project: Meshery (Provisioning / Automation & Configuration)
File: v0.6.176.md

layout: release date: 2023-11-14 tag: v0.6.176 [Models] Update Component Updater to use new Spreadsheet column `PublishToRegistry`. @MUzairS15 (#9362) add mehsery components back @aabidsofi19 (#9359) [mesheryctl] cleanup golden response files @leecalcote (#9237) info modal opening issue fixed in table view @vaibhavpnimkar (#9361) [connections] use default connection chip and fix bugs @sudhanshutech (#9356) [UI] Connections Table enhancements and refactor @aabidsofi19 (#9360) Use Sistent components and packages @sudhanshutech (#9313) [UI] Fix technology and type not showing in Info modal @Yashsharma1911 (#9337) [Server] Clean applications from configuration subscription i @aabidsofi19 (#9354) Bump github.com/nats-io/nkeys from 0.4.5 to 0.4.6 @dependabot (#9253) [DOCS] Build REST API docs @MUzairS15 (#9355) Thank you to our contributors for making this release possible: @MUzairS15, @Yashsharma1911, @aabidsofi19, @alphaX86, @dependabot, @leecalcote, @sudhanshutech and @vaibhavpnimkar
Project: KubeBlocks by ApeCloud (App Definition and Development / Database)
File: delete-kafka-cluster.md

title: Delete a kafka Cluster description: How to delete a kafka Cluster keywords: [kafka, delete a cluster, delete protection] sidebar_position: 7 sidebar_label: Delete protection import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; :::note The termination policy determines how a cluster is deleted. Set the policy when creating a cluster. ::: | terminationPolicy | Deleting Operation | |:-- | :-- | | `DoNotTerminate` | `DoNotTerminate` blocks delete operation. | | `Halt` | `Halt` deletes workload resources such as statefulset, deployment workloads but keep PVCs. | | `Delete` | `Delete` deletes workload resources and PVCs but keep backups. | | `WipeOut` | `WipeOut` deletes workload resources, PVCs and all relevant resources included backups. | To check the termination policy, execute the following command. <Tabs> <TabItem value="kbcli" label="kbcli" default> ```bash kbcli cluster list kafka ``` </TabItem> <TabItem value="kubectl" label="kubectl"> ```bash ~ kubectl -n default get cluster kafka NAME CLUSTER-DEFINITION VERSION TERMINATION-POLICY STATUS AGE kafka kafka kafka-3.3.2 Delete Running 19m ``` </TabItem> </Tabs> Run the command below to delete a specified cluster. <Tabs> <TabItem value="kbcli" label="kbcli" default> ```bash kbcli cluster delete kafka ``` </TabItem> <TabItem value="kubectl" label="kubectl"> If you want to delete a cluster and its all related resources, you can modify the termination policy to `WipeOut`, then delete the cluster. ```bash kubectl patch -n demo cluster kafka -p '{"spec":{"terminationPolicy":"WipeOut"}}' --type="merge" kubectl delete -n demo cluster kafka ``` </TabItem> </Tabs>
Project: OpenTofu (Provisioning / Automation & Configuration)
File: SECURITY.md

Please report any security issue via where the issue will be triaged appropriately. Thank you in advance for helping to keep OpenTofu secure. OpenTofu is a large growing community of volunteers, users, and vendors. The OpenTofu community has adopted this security disclosure and response policy to ensure we responsibly handle critical issues. Security vulnerabilities should be handled quickly and sometimes privately. The primary goal of this process is to reduce the total time users are vulnerable to publicly known exploits. The Product Security Team (PST) is responsible for organizing the entire response including internal communication and external disclosure but will need help from relevant developers to successfully run this process. The initial Product Security Team will consist of members of Steering Committee and Core Development Team. In the future we may decide to have a subset of maintainers work on security response given that this process is time consuming. The OpenTofu community asks that all suspected vulnerabilities be privately and responsibly disclosed via the . If you know of a publicly disclosed security vulnerability please IMMEDIATELY submit a report via to inform the Product Security Team (PST) about the vulnerability so they may start the patch, release, and communication process. If possible the PST will ask the person making the public report if the issue can be handled via a private disclosure process (for example if the full exploit details have not yet been published). If the reporter denies the request for private disclosure, the PST will move swiftly with the fix and release process. In extreme cases GitHub can be asked to delete the issue but this generally isn't necessary and is unlikely to make a public disclosure less damaging. For each vulnerability a member of the PST will volunteer to lead coordination with the "Fix Team" and is responsible for sending disclosure emails to the rest of the community. This lead will be referred to as the "Fix Lead." The role of Fix Lead should rotate round-robin across the PST. Note that given the current size of the OpenTofu community it is likely that the PST is the same as the "Fix team." (I.e., all maintainers). The PST may decide to bring in additional contributors for added expertise depending on the area of the code that contains the vulnerability. The Fix Lead drives the schedule using their best judgment based on severity and development time. If the Fix Lead is dealing with a public disclosure all timelines become ASAP (assuming the vulnerability has a CVSS score >= 4). If the fix relies on another upstream project's disclosure timeline, that will adjust the process as well. We will work with the upstream project to fit their timeline and best protect our users.
Project: KubeDB by AppsCode (App Definition and Development / Database)
File: kubectl-dba_connect_elasticsearch.md

title: Kubectl-Dba Connect Elasticsearch menu: docs_{{ .version }}: identifier: kubectl-dba-connect-elasticsearch name: Kubectl-Dba Connect Elasticsearch parent: reference-cli menuname: docs{{ .version }} sectionmenuid: reference Connect to a shell to run elasticsearch api calls Use this cmd to run api calls to your elasticsearch database. This command connects you to a shell to run curl commands. It exports the following environment variables to run api calls to your database: $USERNAME $PASSWORD $ADDRESS $CACERT $CERT $KEY Example connect command: kubectl dba connect es es-demo -n demo Example curl commands: curl -u $USERNAME:$PASSWORD $ADDRESS/_cluster/health?pretty curl --cacert $CACERT --cert $CERT --key $KEY -u $USERNAME:$PASSWORD $ADDRESS/_cluster/health?pretty ``` kubectl-dba connect elasticsearch [flags] ``` ``` -h, --help help for elasticsearch ``` ``` --as string Username to impersonate for the operation. User could be a regular user or a service account in a namespace. --as-group stringArray Group to impersonate for the operation, this flag can be repeated to specify multiple groups. --as-uid string UID to impersonate for the operation. --cache-dir string Default cache directory (default "/home/runner/.kube/cache") --certificate-authority string Path to a cert file for the certificate authority --client-certificate string Path to a client certificate file for TLS --client-key string Path to a client key file for TLS --cluster string The name of the kubeconfig cluster to use --context string The name of the kubeconfig context to use --default-seccomp-profile-type string Default seccomp profile --disable-compression If true, opt-out of response compression for all requests to the server --insecure-skip-tls-verify If true, the server's certificate will not be checked for validity. This will make your HTTPS connections insecure --kubeconfig string Path to the kubeconfig file to use for CLI requests. --match-server-version Require server version to match client version -n, --namespace string If present, the namespace scope for this CLI request --password string Password for basic authentication to the API server --request-timeout string The length of time to wait before giving up on a single server request. Non-zero values should contain a corresponding time unit (e.g. 1s, 2m, 3h). A value of zero means don't timeout requests. (default "0") -s, --server string The address and port of the Kubernetes API server --tls-server-name string Server name to use for server certificate validation. If it is not provided, the hostname used to contact the server is used --token string Bearer token for authentication to the API server --user string The name of the kubeconfig user to use --username string Username for basic authentication to the API server ``` - Connect to a database.
Project: YDB (App Definition and Development / Database)
File: pcre.md

The Pcre library is currently an alias to . {% if tech or feature_mapreduce %} If you depend on some features of a certain regular expression engine, it's better to internally implement UDF with a given library inside. Use Pcre as the current most-recommended option for simple matching (that can be potentially changed to something else). {% endif %} Currently available engines: <span style="color: gray;">(Intel)</span> <span style="color: gray;">(Yandex)</span> <span style="color: gray;">(Google)</span> All three modules provide approximately the same set of functions with an identical interface. This lets you switch between them with minimal changes to a query. Inside Hyperscan, there are several implementations that use different sets of processor instructions, with the relevant instruction automatically selected based on the current processor. In HyperScan, some functions support backtracking (referencing the previously found part of the string). Those functions are implemented through hybrid use of the two libraries: Hyperscan and libpcre. (Perl Incompatible Regular Expressions) is a very fast library of regular expressions developed by Yandex. At the lower level, it scans the input string once, without any lookaheads or rollbacks, spending 5 machine instructions per character (on x86 and x86_64). However, since the library almost hasn't been developed since 2011-2013 and its name says "Perl incompatible", you may need to adapt your regular expressions a bit. Hyperscan and Pire are best-suited for Grep and Match. The Re2 module uses that offers a wide range of features (). The main benefit of the Re2 is its advanced Capture and Replace functionality. Use this library, if you need those functions.