### Install and Start Quickwit UI

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Install UI dependencies and start the UI development server. Access the UI at http://localhost:3000/ui.

```bash
yarn --cwd quickwit-ui install && yarn --cwd quickwit-ui start
```

--------------------------------

### Install Quickwit CLI

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/tutorials/tutorial-hdfs-logs.md

Download and install the Quickwit CLI. Navigate to the extracted directory after installation.

```bash
curl -L https://install.quickwit.io | sh
cd quickwit-v*/
```

--------------------------------

### Install Quickwit using Installer Script

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/quickstart.md

Download and execute the Quickwit installer script. This method is suitable for supported OS/architectures and requires external dependencies.

```bash
curl -L https://install.quickwit.io | sh
```

```bash
cd ./quickwit-v*/
./quickwit --version
```

--------------------------------

### Start Quickwit Server

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Start the Quickwit server locally. Ensure you are in the `quickwit` subdirectory and have a `qwdata` directory.

```bash
cargo r run --config ../config/quickwit.yaml
```

--------------------------------

### Example Log Output from Indexer

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-otel-collector-with-helm.md

This is an example of the log output you should see from the Quickwit indexer after the OpenTelemetry Collector has started sending logs. It indicates successful indexing and server startup.

```log
2022-11-30T18:27:37.628Z  INFO spawn_merge_pipeline{index=otel-log-v0 gen=0}: quickwit_indexing::actors::merge_pipeline: Spawning merge pipeline. index_id=otel-log-v0 source_id=_ingest-api-source pipeline_ord=0 root_dir=/quickwit/qwdata/indexing/otel-log-v0/_ingest-api-source merge_policy=StableLogMergePolicy { config: StableLogMergePolicyConfig { min_level_num_docs: 100000, merge_factor: 10, max_merge_factor: 12, maturation_period: 172800s }, split_num_docs_target: 10000000 }
2022-11-30T18:27:37.628Z  INFO quickwit_serve::grpc: Starting gRPC server. enabled_grpc_services={"otlp-log", "otlp-trace"} grpc_listen_addr=0.0.0.0:7281
2022-11-30T18:27:37.628Z  INFO quickwit_serve::rest: Starting REST server. rest_listen_addr=0.0.0.0:7280
2022-11-30T18:27:37.628Z  INFO quickwit_serve::rest: Searcher ready to accept requests at http://0.0.0.0:7280/
2022-11-30T18:27:42.654Z  INFO quickwit_indexing::actors::indexer: new-split split_id="01GK4WPTXK8GH3AGTRNBN9A8YG" partition_id=0
2022-11-30T18:27:52.643Z  INFO quickwit_indexing::actors::indexer: send-to-index-serializer commit_trigger=Timeout split_ids=01GK4WPTXK8GH3AGTRNBN9A8YG num_docs=22
2022-11-30T18:27:52.652Z  INFO index_batch{index_id=otel-log-v0 source_id=_ingest-api-source pipeline_ord=0}:packager: quickwit_indexing::actors::packager: start-packaging-splits split_ids=["01GK4WPTXK8GH3AGTRNBN9A8YG"]
2022-11-30T18:27:52.652Z  INFO index_batch{index_id=otel-log-v0 source_id=_ingest-api-source pipeline_ord=0}:packager: quickwit_indexing::actors::packager: create-packaged-split split_id="01GK4WPTXK8GH3AGTRNBN9A8YG"
2022-11-30T18:27:52.653Z  INFO index_batch{index_id=otel-log-v0 source_id=_ingest-api-source pipeline_ord=0}:uploader: quickwit_indexing::actors::uploader: start-stage-and-store-splits split_ids=["01GK4WPTXK8GH3AGTRNBN9A8YG"]
2022-11-30T18:27:52.733Z  INFO index_batch{index_id=otel-log-v0 source_id=_ingest-api-source pipeline_ord=0}:uploader:stage_and_upload{split=01GK4WPTXK8GH3AGTRNBN9A8YG}:store_split: quickwit_indexing::split_store::indexing_split_store: store-split-remote-success split_size_in_megabytes=0.018351 num_docs=22 elapsed_secs=0.07654519 throughput_mb_s=0.23974074 is_mature=false
```

--------------------------------

### List sources in an index

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Lists all configured sources for a given index. Requires the index ID. The example shows how to list sources after starting the Quickwit server.

```bash
# Start a Quickwit server.
quickwit run --service metastore --config=./config/quickwit.yaml
# Open a new terminal and run:
quickwit source list --endpoint=http://127.0.0.1:7280 --index wikipedia
```

--------------------------------

### Start Quickwit Metastore Service

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-metastore-utils/src/bin/README.md

Command to start the quickwit metastore service. This is a prerequisite for running the replay utility.

```bash
./quickwit run --service metastore
```

--------------------------------

### Start Quickwit Server with CLI

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-vector.md

Starts a Quickwit server instance using the command-line interface. Ensure the data directory is created beforehand.

```bash
# Create Quickwit data dir.
mkdir qwdata
./quickwit run
```

--------------------------------

### Install any latest Quickwit release

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Manually pull and execute the installation script with the --allow-any-latest-version flag to install alpha, beta, or rc releases.

```bash
./install.sh --allow-any-latest-version
```

--------------------------------

### Start Quickwit Server

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/distributed-tracing/send-traces/using-otel-collector.md

Run the Quickwit server locally. This command is used to start the Quickwit instance before sending traces.

```bash
./quickwit run
```

--------------------------------

### Start PostgreSQL for Testing

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-metastore/README.md

Starts the PostgreSQL service using the provided Makefile for comprehensive testing, including PostgresqlMetastore.

```bash
$ make docker-compose-up DOCKER_SERVICES=postgres
```

--------------------------------

### Install rust-license-tool

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Install the rust-license-tool from its Git repository to manage project licenses.

```bash
cargo install --git https://github.com/DataDog/rust-license-tool
```

--------------------------------

### Start Quickwit for End-to-End Testing

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/internals/BENCHMARKING.md

Start Quickwit in release mode with a specified configuration file to prepare for end-to-end performance testing.

```bash
cargo run --release -p quickwit-cli -- run --config ../config/quickwit.yaml
```

--------------------------------

### Install sqlx-cli

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-metastore/README.md

Installs the sqlx-cli command-line tool, which can be used for managing database migrations.

```bash
cargo install sqlx-cli
```

--------------------------------

### Install build dependencies on Ubuntu

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/installation.md

Installs necessary development dependencies for compiling Quickwit on Ubuntu.

```bash
apt install -y clang protobuf-compiler libssl-dev pkg-config cmake
```

--------------------------------

### Start Fluentbit service

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-fluentbit.md

Start the Fluent Bit service using the specified configuration file to begin sending logs.

```bash
fluent-bit -c fluent-bit.conf
```

--------------------------------

### Start Indexer and Metastore Services

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Starts the indexer and metastore services for Quickwit. The '--endpoint' flag specifies the address for the REST API.

```bash
quickwit run --service indexer --service metastore --endpoint=http://127.0.0.1:7280
```

--------------------------------

### Verify Quickwit installation with Docker

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/installation.md

Use this command to pull the Quickwit Docker image and verify the installation by checking the version. This is a quick way to get started if you use Docker.

```bash
docker run --rm quickwit/quickwit --version
```

--------------------------------

### Initialize and Apply Example Stack

Source: https://github.com/quickwit-oss/quickwit/blob/main/distribution/ecs/README.md

Run these commands in the ./example directory to deploy the Quickwit stack, including the bastion host and Quickwit cluster. This will provision all necessary AWS resources.

```bash
terraform init
terraform apply
```

--------------------------------

### Get Index Metadata Request Example

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/rest-api.md

Use this GET request to retrieve the metadata for a specific index. Replace `<index id>` with the actual index identifier.

```http
GET api/v1/indexes/<index id>
```

--------------------------------

### Display Help Information

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Use 'quickwit' or 'quickwit --help' to see available commands. Use '<command name> --help' for specific command documentation and examples.

```bash
quickwit --help
```

```bash
quickwit <command name> --help
```

--------------------------------

### Setup Python Virtual Environment with Pipenv

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/rest-api-tests/README.md

Activates a Pipenv shell and installs project dependencies within a virtual environment.

```bash
pipenv shell
pipenv install
```

--------------------------------

### Start Quickwit Server

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/kinesis.md

Launches the Quickwit service in server mode to begin indexing and searching.

```bash
# Finally, execute this command to start Quickwit in server mode.
./quickwit server

```

--------------------------------

### Create Kafka Source Configuration

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/rest-api.md

Example JSON payload for creating a new Kafka source. Ensure the version matches your Quickwit installation and the source_id is unique.

```json
{
    "version": "0.8",
    "source_id": "kafka-source",
    "source_type": "kafka",
    "params": {
        "topic": "quickwit-fts-staging",
        "client_params": {
            "bootstrap.servers": "kafka-quickwit-server:9092"
        }
    }
}
```

--------------------------------

### Pulsar Indexing Pipeline Log

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/pulsar.md

Example log output indicating that Quickwit has started an indexing pipeline for the Pulsar source. This confirms the source is active and consuming data.

```bash
INFO spawn_pipeline{index=stackoverflow gen=0}:pulsar-consumer{subscription_name="quickwit-stackoverflow-pulsar-source" params=PulsarSourceParams { topics: ["stackoverflow"], address: "pulsar://localhost:6650", consumer_name: "quickwit", authentication: None } current_positions={}}: quickwit_indexing::source::pulsar_source: Seeking to last checkpoint positions. positions={}
```

--------------------------------

### Setup and Run Pulsar Data Ingestion

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/pulsar.md

These commands download the dataset, install the Pulsar Python client (requires Python < 3.11), and execute the data ingestion script.

```bash
# Download the first 10_000 Stackoverflow posts articles.
curl -O https://quickwit-datasets-public.s3.amazonaws.com/stackoverflow.posts.transformed-10000.json

# Install pulsar python client.
# Requires a python version < 3.11
pip3 install 'pulsar-client==2.10.1'
wget https://raw.githubusercontent.com/quickwit-oss/quickwit/main/config/tutorials/stackoverflow/send_messages_to_pulsar.py
python3 send_messages_to_pulsar.py
```

--------------------------------

### Start Searcher and Metastore Services for Search Queries

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Launches the searcher and metastore services to enable search requests. Assumes index creation and data ingestion are done separately. A curl command demonstrates making a search request.

```bash
quickwit run --service searcher --service metastore --config=./config/quickwit.yaml
# Make a request.
curl "http://127.0.0.1:7280/api/v1/wikipedia/search?query=barack+obama"
```

--------------------------------

### Basic Actor Ping-Pong Example

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-actors/README.md

Demonstrates a simple actor setup with a sender and receiver. The sender periodically sends a 'Ping' message to the receiver and prints the 'Pong' reply. It also schedules itself to send messages after a delay.

```rust
use std::time::Duration;
use async_trait::async_trait;
use quickwit_actors::{Handler, Actor, Universe, ActorContext, ActorExitStatus, Mailbox};

#[derive(Default)]
struct PingReceiver;

impl Actor for PingReceiver {
    type ObservableState = ();
    fn observable_state(&self) -> Self::ObservableState {}
}

#[async_trait]
impl Handler<Ping> for PingReceiver {
    type Reply = String;
    async fn handle(
        &mut self,
        _msg: Ping,
        _ctx: &ActorContext<Self>,
    ) -> Result<String, ActorExitStatus> {
        Ok("Pong".to_string())
    }
}

struct PingSender {
    peer: Mailbox<PingReceiver>,
}

#[derive(Debug)]
struct Loop;

#[derive(Debug)]
struct Ping;

#[async_trait]
impl Actor for PingSender {
    type ObservableState = ();
    fn observable_state(&self) -> Self::ObservableState {}

    async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(),ActorExitStatus> {
        ctx.send_self_message(Loop).await?;
        Ok(())
    }
}

#[async_trait]
impl Handler<Loop> for PingSender {
    type Reply = ();

    async fn handle(
        &mut self,
        _: Loop,
        ctx: &ActorContext<Self>,
    ) -> Result<(), ActorExitStatus> {
        let reply_msg = ctx.ask(&self.peer, Ping).await.unwrap();
        println!("{reply_msg}");
        ctx.schedule_self_msg(Duration::from_secs(1), Loop).await;
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    let universe = Universe::new();

    let (recv_mailbox, _) = 
        universe.spawn_actor(PingReceiver::default()).spawn();

    let ping_sender = PingSender { peer: recv_mailbox };
    let (_, ping_sender_handler) = universe.spawn_actor(ping_sender).spawn();

    ping_sender_handler.join().await;
}
```

--------------------------------

### Run UI Tests

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Install UI dependencies and run the UI tests. This should be executed from the `quickwit` directory.

```bash
yarn --cwd quickwit-ui install && yarn --cwd quickwit-ui test
```

--------------------------------

### Start Control Plane, Metastore, and Janitor Services

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Initiates the control plane, metastore, and janitor services using a specified configuration file.

```bash
quickwit run --service control_plane --service metastore --service janitor --config=./config/quickwit.yaml
```

--------------------------------

### Install TLA+ Toolbox via Homebrew

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/internals/specs/tla/README.md

Installs the TLA+ Toolbox using Homebrew. Ensure Java is installed separately.

```bash
brew install tlaplus
```

--------------------------------

### Get Index Template GET Request

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/rest-api.md

Retrieve a specific index template configuration by its ID using a GET request to this endpoint.

```http
GET api/v1/templates/<template id>
```

--------------------------------

### Run Command

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/reference/cli.md

Starts a Quickwit node with specified services enabled.

```APIDOC
## run

Starts a Quickwit node with all services enabled by default: `indexer`, `searcher`, `metastore`, `control-plane`, and `janitor`.

### Indexer service

The indexer service runs indexing pipelines assigned by the control plane.

### Searcher service 
Starts a web server at `rest_listing_address:rest_list_port` that exposes the [Quickwit REST API](rest-api.md) where `rest_listing_address` and `rest_list_port` are defined in Quickwit config file (quickwit.yaml). The node can optionally join a cluster using the `peer_seeds` parameter. This list of node addresses is used to discover the remaining peer nodes in the cluster through a gossip protocol, see [chitchat](https://github.com/quickwit-oss/chitchat).

### Metastore service

The metastore service exposes Quickwit metastore over the network. This is a core internal service that is needed to operate Quickwit. As such, at least one running instance of this service is required for other services to work.

### Control plane service

The control plane service schedules indexing tasks to indexers. It listens to metastore events such as an source create, delete, toggle, or index delete and reacts accordingly to update the indexing plan.

### Janitor service

The Janitor service runs maintenance tasks on indexes: garbage collection, documents delete, and retention policy tasks.

:::note
Quickwit needs to open the following port for cluster formation and workload distribution:

    TCP port (default is 7280) for REST API
    TCP and UDP port (default is 7280) for cluster membership protocol
    TCP port + 1 (default is 7281) for gRPC address for the distributed search

If ports are already taken, the serve command will fail.
:::
  
`quickwit  run [args]`

*Synopsis*

```bash
quickwit run
    [--config <config>]
    [--service <service>]
```

*Options*

| Option | Description | Default | 
|-----------------|-------------|--------:|
| `--config` | Config file location | `config/quickwit.yaml` |
| `--service` | Services (`indexer`, `searcher`, `metastore`, `control-plane`, or `janitor`) to run. If unspecified, all the supported services are started. |  |

*Examples*

*Starts an indexer and a metastore services*
```bash
quickwit run --service indexer --service metastore --endpoint=http://127.0.0.1:7280
```

*Start a control plane, metastore and janitor services*
```bash
quickwit run --service control_plane --service metastore --service janitor --config=./config/quickwit.yaml
```

*Make a search request on a wikipedia index*
```bash
# To create wikipedia index and ingest data, go to our tutorials https://quickwit.io/docs/get-started/.
# Start a searcher.
quickwit run --service searcher --service metastore --config=./config/quickwit.yaml
# Make a request.
curl "http://127.0.0.1:7280/api/v1/wikipedia/search?query=barack+obama"

```
```

--------------------------------

### Run Quickwit

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/tutorials/tutorial-hdfs-logs-distributed-search-aws-s3.md

Start the Quickwit node using the generated configuration file.

```bash
./quickwit run --config config.yaml
```

--------------------------------

### Testing Quickwit Through Production Path

Source: https://github.com/quickwit-oss/quickwit/blob/main/CLAUDE.md

This sequence demonstrates how to test Quickwit by starting the service, ingesting data via OTLP, and querying the data through the REST API.

```bash
# 1. Start quickwit
cargo run -p quickwit-cli -- run --config ../config/quickwit.yaml

# 2. Ingest via OTLP
# (send logs/traces to localhost:4317)

# 3. Query via REST API
curl http://localhost:7280/api/v1/<index>/search -d '{"query": "*"}'
```

--------------------------------

### Start Quickwit Server with Docker

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-vector.md

Starts a Quickwit server instance using Docker. This command mounts a local directory for data persistence and maps the necessary port.

```bash
# Create Quickwit data dir.
mkdir qwdata
docker run --rm -v $(pwd)/qwdata:/quickwit/qwdata -p 7280:7280 quickwit/quickwit run
```

--------------------------------

### Example Log Entry

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/tutorials/tutorial-hdfs-logs.md

An example of a log entry structure in JSON format.

```json
{
  "timestamp": 1460530013,
  "severity_text": "INFO",
  "body": "PacketResponder: BP-108841162-10.10.34.11-1440074360971:blk_1074072698_331874, type=HAS_DOWNSTREAM_IN_PIPELINE terminating",
  "resource": {
    "service": "datanode/01"
  },
  "attributes": {
    "class": "org.apache.hadoop.hdfs.server.datanode.DataNode"
  },
  "tenant_id": 58
}
```

--------------------------------

### Install Pipenv

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/rest-api-tests/README.md

Installs Pipenv, a dependency manager for Python projects, using pip.

```bash
pip install --user pipenv
```

--------------------------------

### Create Quickwit Index

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/pulsar.md

Downloads the index configuration and creates the 'stackoverflow' index in Quickwit.

```bash
# Download stackoverflow index config.
wget -O stackoverflow.yaml https://raw.githubusercontent.com/quickwit-oss/quickwit/main/config/tutorials/stackoverflow/index-config.yaml

# Create index.
./quickwit index create --index-config stackoverflow.yaml
```

--------------------------------

### Install TLA+ Toolbox

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/internals/specs/tla/CLAUDE.md

Installs the TLA+ Toolbox application using Homebrew cask.

```bash
brew install --cask tla+-toolbox
```

--------------------------------

### Quickwit CLI Commands for Indexing and Searching

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/guides/schemaless.md

Demonstrates the command-line interface usage for creating an index with a dynamic configuration, ingesting JSON documents, and performing a search query.

```bash
cat << EOF > my_dynamic_index.yaml
version: 0.7
index_id: my_dynamic_index
doc_mapping:
  mode: dynamic
  field_mappings:
    - name: timestamp
      type: datetime
      input_formats:
        - unix_timestamp
      output_format: unix_timestamp_secs
      fast_precision: seconds
      fast: true
    - name: user_id
      type: text
      tokenizer: raw
    - name: event_type
      type: text
      tokenizer: raw
  timestamp_field: timestamp

indexing_settings:
  commit_timeout_secs: 30
EOF

# Create index.
./quickwit index create --index-config ./my_dynamic_index.yaml --overwrite --yes

cat << EOF > my_logs.json
{"timestamp":1653021741,"user_id":"8705a7fak","event_type":"login","ab_groups":["phoenix-red-ux"]}
{"timestamp":1653021746,"user_id":"7618fe06","event_type":"order","ab_groups":["phoenix-red-ux","new-ranker"],"cart":[{"product_id":120391,"product_description":"Cherry Pi: A single-board computer that is compatible..."}]}
{"timestamp":1653021748,"user_id":"8705a7fak","event_type":"login","ab_groups":["phoenix-red-ux"]}
EOF

# Ingest documents.
./quickwit index ingest --index my_dynamic_index --input-path my_logs.json --force

# Execute search query.
./quickwit index search --index my_dynamic_index --query "event_type:order AND cart.product_id:120391


```

--------------------------------

### Install tokio-console

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Install the tokio-console tool to enable runtime introspection of Tokio applications.

```bash
cargo install tokio-console
```

--------------------------------

### Install libssl on Ubuntu

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/installation.md

Installs the libssl library required for Quickwit on Ubuntu systems.

```bash
apt-get -y update && apt-get -y install libssl
```

--------------------------------

### Create and Set Namespace

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-otel-collector-with-helm.md

Creates a new Kubernetes namespace for the tutorial and sets it as the current context.

```bash
kubectl create namespace qw-tutorial
kubectl config set-context --current --namespace=qw-tutorial
```

--------------------------------

### Create Index using CLI

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/ingest-api.md

Uses the Quickwit CLI to create an index from a configuration file.

```bash
./quickwit index create --index-config stackoverflow-schemaless-config.yaml
```

--------------------------------

### Install OpenTelemetry Bootstrap

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/distributed-tracing/send-traces/using-otel-sdk-python.md

Install the opentelemetry-bootstrap tool, which is used for automatically instrumenting Python applications.

```bash
opentelemetry-bootstrap -a install
```

--------------------------------

### Install Quickwit Helm Chart

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/log-management/send-logs/using-otel-collector-with-helm.md

Installs the Quickwit Helm chart using the specified values file. Ensure S3 access is verified prior to execution.

```bash
helm install quickwit quickwit/quickwit -f qw-tutorial-values.yaml
```

--------------------------------

### Install Dependencies with Yarn

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-ui/README.md

Installs local Node.js dependencies required for the project. Run this after cloning the repository.

```bash
yarn
```

--------------------------------

### Ingest Example Dataset

Source: https://github.com/quickwit-oss/quickwit/blob/main/distribution/ecs/README.md

Download a sample dataset and use curl to POST it to the Quickwit indexer API for ingestion. The `commit=force` parameter ensures data is immediately available.

```bash
wget https://quickwit-datasets-public.s3.amazonaws.com/hdfs-logs-multitenants-10000.json
curl -X POST \
  -H "content-type: application/json" \
  --data-binary @hdfs-logs-multitenants-10000.json \
  http://indexer.quickwit:7280/api/v1/hdfs-logs/ingest?commit=force
```

--------------------------------

### Install libssl on Arch Linux

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/installation.md

Installs the openssl package required for Quickwit on Arch Linux systems.

```bash
pacman -S openssl
```

--------------------------------

### Run Quickwit Metastore Replay Utility

Source: https://github.com/quickwit-oss/quickwit/blob/main/quickwit/quickwit-metastore-utils/src/bin/README.md

Execute the replay utility from the quickwit-metastore directory. Assumes a metastore service is running on localhost:7280.

```bash
cargo run --release --bin replay
```

--------------------------------

### Install libssl on AWS Linux

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/get-started/installation.md

Installs the openssl package required for Quickwit on AWS Linux systems.

```bash
yum -y update && yum -y install openssl
```

--------------------------------

### Download and Create Kinesis Source

Source: https://github.com/quickwit-oss/quickwit/blob/main/docs/ingest-data/kinesis.md

Downloads the Kinesis source configuration file and then uses the Quickwit CLI to create the source for the 'gh-archive' index.

```bash
# Download Kinesis source config.
wget https://raw.githubusercontent.com/quickwit-oss/quickwit/main/config/tutorials/gh-archive/kinesis-source.yaml

# Create source.
./quickwit source create --index gh-archive --source-config kinesis-source.yaml

```

--------------------------------

### Start Docker Services

Source: https://github.com/quickwit-oss/quickwit/blob/main/CONTRIBUTING.md

Start the Docker services required for development. You can specify a subset of services to launch.

```bash
make docker-compose-up
```

```bash
make docker-compose-up DOCKER_SERVICES=kafka,postgres
```