Alibabacloud Sls Index Config Management

Alibaba Cloud SLS Index Configuration Manager

Scenario Description

Use this skill for SLS Logstore index configuration.

This file only covers trigger-time setup, routing, and cross-scenario safety. Read only the reference document needed for the user's request.

---

Prerequisites

Install Aliyun CLI

Run aliyun version to verify the version is >= 3.3.8. If not installed or outdated, follow references/cli-installation-guide.md to install or update.

Ensure AI Mode Enabled

Before executing any SLS API commands, enable AI-Mode, set User-Agent, and update plugins:

aliyun configure ai-mode enable
aliyun configure ai-mode set-user-agent --user-agent "AlibabaCloud-Agent-Skills/alibabacloud-sls-index-config-management"
aliyun plugin update

Check Alibaba Cloud credentials configured

Run aliyun configure list to check if credentials are configured. If no valid profile is shown, STOP here and ask the user to run aliyun configure outside of this session.

Security rules:

• NEVER read, echo, or print AK/SK values
• NEVER ask the user to paste AK/SK into the conversation
• ONLY use aliyun configure list to check credential status

---

RAM Permission Requirements

On Unauthorized error, surface references/ram-policies.md to the user. Do not retry with a different account without explicit confirmation.

---

Routing the Request

After environment and credential checks, classify the user's request and follow the matching reference:

Mixed requests are common (e.g. "generate an index for these logs and then update it on Logstore X"). Read the relevant scenario docs in order.

---

Global Rules

• No writes without the scenario reference. Before any write operation, read the relevant reference document and follow its confirmation, full-body, rollback, and timing rules.
• Use exact SLS CLI names. Product is sls; subcommands and flags are kebab-case. Use references/acceptance-criteria.md only when validating command shape or debugging CLI invocation issues.

Output Format

Every time you present an index configuration to the user — whether from a read (get-index), after a write (create-index / update-index), or during generation/optimization — output both:

1. Complete JSON — the full get-index JSON response (or the equivalent JSON body you are about to submit for a write). Wrap it in a fenced json code block so the user can copy-paste it directly. 2. Human-readable summary

Put the Complete JSON first, then the summary. The summary helps the user understand the config at a glance; the JSON is the authoritative, machine-readable reference they can use for scripting, version control, or future update-index calls.

---

Cleanup

Whether operations succeed or fail, you MUST disable AI-Mode before ending the session:

aliyun configure ai-mode disable

---

Reference Documents

Acceptance Criteria: sls-index-config-manager

Scenario: SLS Index Configuration Management Purpose: Skill testing acceptance criteria

---

Correct CLI Invocation Patterns

1. Command Format — verify product and API name

CORRECT

aliyun sls get-index --project my-project --logstore my-logstore

aliyun sls create-index \
  --project my-project --logstore my-logstore \
  --line "$(cat /tmp/line.json)" \
  --keys "$(cat /tmp/keys.json)"


aliyun sls delete-index --project my-project --logstore my-logstore

INCORRECT — Wrong product name

aliyun log get-index --project my-project --logstore my-logstore
aliyun logservice create-index --project p --logstore l

Why: Product name is sls, not log, logservice, aliyunlog, or aliyun-sls.

2. Parameter Format

CORRECT — Kebab-case sub-command and flags

aliyun sls update-index \
  --project my-project --logstore my-logstore \
  --line "$(cat /tmp/line.json)" \
  --keys "$(cat /tmp/keys.json)" \
  --max-text-len 4096

INCORRECT — PascalCase sub-command or flags

aliyun sls UpdateIndex --Project p --Logstore l --Keys ...
aliyun sls GetIndex --Project p

Why: The SLS plugin uses kebab-case for both sub-commands (get-index, create-index, update-index, delete-index) and flags (--project, --logstore, --line, --keys, --max-text-len).

INCORRECT — JSON --params blob

aliyun sls update-index --params '{"Project":"p","Logstore":"l","Keys":{...}}'

Why: The CLI takes individual flags, not a JSON --params blob.

3. Index Body Passing — always via file

CORRECT — Write JSON to file, then pass with $(cat ...)

cat > /tmp/line.json <<'EOF'
{
  "caseSensitive": false,
  "chn": false,
  "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
}
EOF

cat > /tmp/keys.json <<'EOF'
{
  "status": { "type": "long", "doc_value": true },
  "request_uri": {
    "type": "text",
    "doc_value": true,
    "caseSensitive": false,
    "chn": false,
    "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", ":", "/", "\n", "\t", "\r"]
  }
}
EOF

aliyun sls create-index \
  --project my-project --logstore my-logstore \
  --line "$(cat /tmp/line.json)" \
  --keys "$(cat /tmp/keys.json)"

INCORRECT — Inline multi-line JSON with shell-special characters

aliyun sls create-index --project p --logstore l \
  --keys '{
    "request_uri": {"type":"text","token":[",", " ", "\n", "\t"]}
  }'

Why: Tokenizer arrays usually contain backslash escapes (\n, \t, \r) and quotes. Inline multi-line JSON in the shell breaks quoting; always serialize to a file first.

4. UpdateIndex — complete config replacement

CORRECT — Submit the complete final config

aliyun sls get-index --project my-project --logstore my-logstore > /tmp/current.json

# Prepare /tmp/line.json and /tmp/keys.json as the final complete config.

aliyun sls update-index \
  --project my-project --logstore my-logstore \
  --line "$(cat /tmp/line.json)" \
  --keys "$(cat /tmp/keys.json)" \
  --max-text-len 2048

INCORRECT — Sending only a partial field fragment

aliyun sls update-index \
  --project my-project --logstore my-logstore \
  --keys '{"new_field":{"type":"long","doc_value":true}}'

Why: update-index is overwrite — submitting only keys drops line, max_text_len, log_reduce, and every existing field that was not re-included.

5. CreateIndex vs UpdateIndex — pick by current state

CORRECT — Branch on whether get-index succeeds

if aliyun sls get-index --project p --logstore l > /tmp/cur.json 2>/tmp/err; then
  aliyun sls update-index \
    --project p --logstore l \
    --line "$(cat /tmp/line.json)" \
    --keys "$(cat /tmp/keys.json)"
else
  grep -q IndexConfigNotExist /tmp/err && \
    aliyun sls create-index \
      --project p --logstore l \
      --line "$(cat /tmp/line.json)" \
      --keys "$(cat /tmp/keys.json)"
fi

INCORRECT — Always calling create-index

aliyun sls create-index --project p --logstore l --line "..." --keys "..."

Why: If an index already exists, create-index fails with IndexAlreadyExist. Always inspect first.

6. DeleteIndex — explicit confirmation required

CORRECT — Confirm and capture a snapshot before deleting

aliyun sls get-index --project p --logstore l > /tmp/index-backup-$(date +%s).json

# After explicit user confirmation:
aliyun sls delete-index --project p --logstore l

INCORRECT — Chaining delete-index after a write

aliyun sls update-index --project p --logstore l --line "..."
aliyun sls delete-index --project p --logstore l

Why: delete-index removes the entire index and breaks query / SQL on that Logstore. The skill never chains it after other writes and must obtain explicit user confirmation.

7. Authentication — never expose credentials

CORRECT — Verify credential profile via default credential chain

aliyun configure list

INCORRECT — Passing AK/SK directly in the command

aliyun sls update-index \
  --access-key-id LTAI5tXXXX \
  --access-key-secret 8dXXXX \
  --project p --logstore l --line "..."

Why: Credentials must come from the configured profile, environment variables, STS, or RAM role — never be typed into the command line.

INCORRECT — Reading or printing raw credentials

aliyun configure get        # FORBIDDEN: may expose credential details
cat ~/.aliyun/config.json   # FORBIDDEN: may expose credential details

INCORRECT — Any command that prints environment credentials

echo $ALIBABA_CLOUD_ACCESS_KEY_ID       # FORBIDDEN
printenv | grep -i credential           # FORBIDDEN
env | grep -i access_key                # FORBIDDEN

8. API Names — verify exact sub-command

CORRECT

get-index        # OpenAPI Action: GetIndex
create-index     # OpenAPI Action: CreateIndex
update-index     # OpenAPI Action: UpdateIndex
delete-index     # OpenAPI Action: DeleteIndex

INCORRECT

GetIndex            # PascalCase is the Action name, not the CLI sub-command
getIndex            # Wrong casing
get_index           # Wrong separator (snake_case)
getindex            # Missing separator
describe-index      # Wrong verb — SLS uses get-, not describe-
put-index           # Wrong verb — use update-index
modify-index        # Not a real sub-command
get-log-index       # Not a real sub-command — use get-index

9. Region Parameter

CORRECT

--region cn-hangzhou
--region cn-shanghai
--region ap-southeast-1

INCORRECT

--region hangzhou       # Missing country prefix
--region cn-hangzhou-1  # Not a real region ID
--region-id cn-hangzhou # CLI global flag is --region, not --region-id

Workflow Checklist

When the skill executes a write, it must satisfy all of:

• [ ] aliyun configure list was run and returned a configured profile.
• [ ] AI mode was enabled (aliyun configure ai-mode enable).
• [ ] get-index was called and the response was captured to a file before any write.
• [ ] Index body was written to /tmp/<name>.json (not inlined).
• [ ] update-index body is the full desired configuration, not a partial fragment.
• [ ] For delete-index, the user gave explicit confirmation and a backup file was written.
• [ ] AI mode was disabled at the end of the session (aliyun configure ai-mode disable).

Aliyun CLI Installation & Configuration Guide

Complete guide for installing and configuring Aliyun CLI for the index configuration manager skill.

Aliyun CLI 3.3.8+: Supports installing and using all published Alibaba Cloud product plugins.

Make sure to upgrade to 3.3.8 or later for full plugin ecosystem coverage, including the sls plugin used by this skill.

Installation

macOS

Using Homebrew (Recommended)

brew install aliyun-cli
brew upgrade aliyun-cli

aliyun version

Using Binary

wget https://aliyuncli.alicdn.com/aliyun-cli-macosx-latest-amd64.tgz
tar -xzf aliyun-cli-macosx-latest-amd64.tgz
sudo mv aliyun /usr/local/bin/

aliyun version

Linux

Debian/Ubuntu and CentOS/RHEL (amd64)

wget https://aliyuncli.alicdn.com/aliyun-cli-linux-latest-amd64.tgz
tar -xzf aliyun-cli-linux-latest-amd64.tgz
sudo mv aliyun /usr/local/bin/

aliyun version

ARM64 Architecture

wget https://aliyuncli.alicdn.com/aliyun-cli-linux-latest-arm64.tgz
tar -xzf aliyun-cli-linux-latest-arm64.tgz
sudo mv aliyun /usr/local/bin/

Windows

Using Binary

1. Download from <https://aliyuncli.alicdn.com/aliyun-cli-windows-latest-amd64.zip> 2. Extract the ZIP 3. Add the directory to your PATH 4. Open a new Command Prompt or PowerShell 5. Verify with aliyun version

Using PowerShell

Invoke-WebRequest -Uri "https://aliyuncli.alicdn.com/aliyun-cli-windows-latest-amd64.zip" -OutFile "aliyun-cli.zip"
Expand-Archive -Path aliyun-cli.zip -DestinationPath C:\aliyun-cli
$env:Path += ";C:\aliyun-cli"
[Environment]::SetEnvironmentVariable("Path", $env:Path, [System.EnvironmentVariableTarget]::Machine)

aliyun version

Install / Update the SLS Plugin

aliyun plugin update
aliyun plugin install --names sls   # only if `aliyun sls --help` says "command not found"
aliyun sls --help

Configuration

Credential Setup

The skill may check whether credentials exist, but it must not read or print credential values. Use only this command inside the agent session:

aliyun configure list

If no valid profile is listed, stop and ask the user to configure credentials in their own terminal. The user can run the interactive wizard:

aliyun configure

Aliyun CLI supports AK, StsToken, RamRoleArn, EcsRamRole, RsaKeyPair, and RamRoleArnWithEcs authentication modes. Pick the mode that matches the deployment environment:

Credential priority, highest first:

1. --profile <name> command-line flag. 2. ALIBABA_CLOUD_PROFILE. 3. Environment credentials already present in the process environment. 4. The active profile in the Aliyun CLI config file. 5. ECS instance RAM role.

When multiple profiles are configured, use a profile-specific command rather than changing global state:

aliyun sls get-index --profile projectA --project p --logstore l

Do not run commands that display secret values, such as aliyun configure get, cat ~/.aliyun/config.json, or commands that print credential environment variables.

Verification

Test Authentication

aliyun ecs describe-regions

Successful invocation returns a JSON list of regions. Any of the following errors indicates a credential issue:

• InvalidAccessKeyId.NotFound
• SignatureDoesNotMatch
• InvalidSecurityToken.Expired
• Forbidden.RAM

Test SLS plugin & permissions

aliyun sls get-index --project <project> --logstore <logstore>

• Success → both CLI and log:GetIndex are working.
• IndexConfigNotExist (404) → CLI is working; the Logstore simply has no index. Proceed to the create-index workflow.
• Unauthorized → grant the policies in ram-policies.md.

Security Best Practices

1. Use RAM users, not the root account. 2. Principle of least privilege — grant only the actions in ram-policies.md that match the user's task. 3. Rotate access keys regularly. 4. Prefer STS or ECS RAM Role for temporary or in-cloud workflows. 5. Never commit `~/.aliyun/config.json`; add it to .gitignore. 6. chmod 600 ~/.aliyun/config.json to restrict local file permissions.

Troubleshooting

Issue: Command Not Found

which aliyun
echo $PATH

Reinstall or add the binary directory to PATH.

Issue: aliyun sls --help says "command not found"

aliyun plugin update
aliyun plugin install --names sls

Issue: Authentication Failed

aliyun configure list
aliyun ecs describe-regions

Issue: Permission Denied (Forbidden.RAM)

Check that the RAM user has the policies described in ram-policies.md.

Issue: Wrong Region

aliyun sls get-index --region cn-shanghai --project <project> --logstore <logstore>

A Project lives in exactly one region; a region mismatch returns ProjectNotExist.

Advanced Configuration

Custom Endpoint

export ALIBABA_CLOUD_LOG_ENDPOINT=<custom-or-internal-sls-endpoint>

Proxy Settings

export HTTP_PROXY=http://proxy.example.com:8080
export HTTPS_PROXY=http://proxy.example.com:8080
export NO_PROXY=localhost,127.0.0.1,.aliyuncs.com

Timeout Settings

export ALIBABA_CLOUD_CONNECT_TIMEOUT=30
export ALIBABA_CLOUD_READ_TIMEOUT=30

References

• Official Documentation: <https://help.aliyun.com/zh/cli/>
• RAM Console: <https://ram.console.aliyun.com/>
• Access Key Management: <https://ram.console.aliyun.com/manage/ak>
• Aliyun CLI source: <https://github.com/aliyun/aliyun-cli>

Generate Index Configuration from Log Samples

Use this reference when the user provides multiple structured log samples and wants an SLS field index config inferred from them.

For direct index config operations and CLI examples, see manage-index-config.md. For workload/cost/throughput tuning on an existing index, see optimize-index-config.md.

Workflow

1. Run get-index and save the current index config as a backup if an index exists. If IndexConfigNotExist is returned, skip the backup and plan to use create-index. 2. Analyze the user-provided samples and infer each field's SLS index type. 3. Generate the complete final index config. 4. Output the final index config and the matching create-index or update-index CLI command.

Generation Rules

Use user-provided structured log samples. The expected shape is a single-level key/value map: { "field": value, ... }.

Generate keys only by default. Do not generate a full-text line index unless the user asks for full-text keyword search.

For each top-level field:

1. Inspect all non-empty sample values for that field. 2. Infer the narrowest compatible SLS type. 3. Add one keys.<field> entry. 4. Set doc_value: false unless the user explicitly says the field is needed for SQL analytics (SELECT, WHERE, GROUP BY, ORDER BY, aggregations).

Do not make assumptions from field names alone. For example, do not set doc_value: true just because a field is named status, request_time, or user_id.

Type Inference

Text defaults:

{
  "type": "text",
  "doc_value": false,
  "caseSensitive": false,
  "chn": false,
  "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
}

JSON Fields

For an SLS json field, do not use index_all by default. Parse the JSON object strings and configure only first-level scalar keys under json_keys.

Rules:

• Infer json_keys.<key>.type from that first-level key's sample values.
• Use only text, long, or double inside json_keys.
• Do not configure token inside json_keys; text subkeys use the parent json field's

tokenizer.

• Do not recurse into nested objects/arrays unless the user explicitly asks.

Example for field extra:

{
  "type": "json",
  "doc_value": false,
  "caseSensitive": false,
  "chn": false,
  "token": [",", " ", ":", "-", "\n", "\t", "\r"],
  "json_keys": {
    "trace_id": {
      "type": "text",
      "doc_value": false,
      "caseSensitive": false,
      "chn": false
    },
    "region": {
      "type": "text",
      "doc_value": false,
      "caseSensitive": false,
      "chn": false
    },
    "cost": {
      "type": "double",
      "doc_value": false
    }
  }
}

Output

Return a concise field inference summary, the complete generated index config, and the matching create-index or update-index command from manage-index-config.md.

Example Output

Example keys config (three representative field types):

{
  "request_uri": {
    "type": "text",
    "doc_value": false,
    "caseSensitive": false,
    "chn": false,
    "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
  },
  "status": {
    "type": "long",
    "doc_value": false
  },
  "extra": {
    "type": "json",
    "doc_value": false,
    "caseSensitive": false,
    "chn": false,
    "token": [",", " ", ":", "-", "\n", "\t", "\r"],
    "json_keys": {
      "trace_id": { "type": "text", "doc_value": false, "caseSensitive": false, "chn": false },
      "cost": { "type": "double", "doc_value": false }
    }
  }
}

Manage Index Configuration

Use this reference for direct SLS Logstore index work: view, create, replace, or delete an index configuration.

Use aliyun help sls <subcommand> for command-specific flags and examples, such as aliyun help sls create-index.

Core Rules

• create-index and update-index use nearly the same flags. Use create-index when no index

exists; use update-index when replacing an existing config.

• update-index overwrites the whole index config. The submitted line / keys files must

represent the complete final config, not a partial fragment.

• At least one of line, keys, or scan_index must be present.
• Object-valued parameters such as line and keys should be written to /tmp/*.json and

passed with $(cat /tmp/file.json).

• Index writes apply only to new logs after propagation, usually within ~1 minute.

Index Basics

SLS index config is mainly line + keys.

Common field types:

Common field options:

• doc_value: enable SQL analytics for the field. Use it for fields in SELECT, WHERE,

GROUP BY, ORDER BY, or aggregations.

• caseSensitive: case-sensitive text matching.
• chn: Chinese tokenization. Keep false unless Chinese keyword search is needed and user requires it.
• token: token delimiters for full-text/text fields.
• index_all, max_depth, json_keys: JSON indexing controls.

Examples

Each example shows the JSON file(s), then the matching create-index and update-index commands.

Full-Text Only

/tmp/sls-index-line.json:

{
  "caseSensitive": false,
  "chn": false,
  "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
}

aliyun sls create-index \
  --project <project> --logstore <logstore> \
  --line "$(cat /tmp/sls-index-line.json)" \
  --max-text-len 2048

Full-Text + Field Indexes

/tmp/sls-index-line.json:

{
  "caseSensitive": false,
  "chn": false,
  "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
}

/tmp/sls-index-keys.json:

{
  "status": { "type": "long", "doc_value": true },
  "request_time": { "type": "double", "doc_value": true },
  "request_uri": {
    "type": "text",
    "doc_value": true,
    "caseSensitive": false,
    "chn": false,
    "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", ":", "/", "\n", "\t", "\r"]
  }
}

aliyun sls update-index \
  --project <project> --logstore <logstore> \
  --line "$(cat /tmp/sls-index-line.json)" \
  --keys "$(cat /tmp/sls-index-keys.json)" \
  --max-text-len 2048

Common Errors

Optimize Index Configuration

Adjust an existing SLS index config for a query, SQL statement, write throughput, or storage cost.

Process

1. Run get-index and save the current index config as a backup. 2. Analyze the user's requirement, the current index config, and any relevant context such as query statements, SQL statements, sample fields, cost concerns, or write-throughput concerns. 3. Generate the complete optimized line / keys config. 4. Produce an optimization report explaining what changed and why. 5. Provide the update-index CLI command that submits the complete optimized config.

Principles

• Missing fields in query: if a query references a field that is not in keys, add that field

to the field index.

• Missing SQL fields: if SQL uses a field in SELECT, WHERE, GROUP BY, ORDER BY, or an

aggregation, the field index needs doc_value: true.

• No-token fields: for identifier-like fields that do not need tokenization, such as

request_id, trace_id, span_id, user_id, or exact-match IDs, remove unnecessary token delimiters. Keep tokenization minimal for exact-match fields.

• Chinese indexing: prefer chn: false. Enable Chinese tokenization only when the user

explicitly needs Chinese keyword search on that field.

• Long unstructured text: for long, unstructured fields that are unlikely to be used in SQL

analysis, such as content, message, or raw_payload, set doc_value: false to reduce storage overhead.

• Deep JSON fields: control JSON index depth carefully. For very deep JSON fields, avoid

indexing excessive depth; generally do not exceed 5 levels unless the user explicitly needs it.

• Integer fields: if all observed values for a field are integers, prefer long over text.

Guardrails

• Keep the user's required query or SQL working; do not remove needed indexes to save cost unless

the user accepts that tradeoff.

• update-index replaces the full config. Submit the complete final line / keys config, not

only the optimized field.

• Explain any behavior change, especially removing tokenization, disabling doc_value, reducing

JSON depth, or turning off Chinese tokenization.

Output

• Optimized line / keys JSON files.
• Brief optimization report: only list meaningful changes and why.
• Complete aliyun sls update-index ... command.

RAM Policies - SLS Index Configuration Manager

Required Permissions

Resource: acs:log:{regionId}:{accountId}:project/{ProjectName}/logstore/{LogstoreName}

ARN placeholders: {regionId} (e.g. cn-hangzhou, or *), {accountId} (UID or *), {ProjectName} (or *), {LogstoreName} (or *).

Minimum RAM Policy (read-only)

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["log:GetIndex"],
      "Resource": "acs:log:*:*:project/<project-name>/logstore/<logstore-name>"
    }
  ]
}

Complete RAM Policy

{
  "Version": "1",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "log:GetIndex",
        "log:CreateIndex",
        "log:UpdateIndex",
        "log:DeleteIndex"
      ],
      "Resource": "acs:log:*:*:project/<project-name>/logstore/<logstore-name>"
    }
  ]
}

Use logstore/* to match all Logstores under a project, or project/* to match all projects.

Grant only the actions needed: start with GetIndex for inspection, add write actions when needed, add DeleteIndex only when the user explicitly requests deletion.

Related APIs - SLS Index Configuration Manager

This document is the API / CLI reference for the index management skill. It covers the four index-management endpoints: GetIndex, CreateIndex, UpdateIndex, and DeleteIndex.

Command List

---

CLI Conventions

• Always use the product namespace aliyun sls and kebab-case subcommands / flags.
• Do not use PascalCase OpenAPI action names (UpdateIndex) as CLI subcommands.
• Do not pass a JSON --params blob. The SLS plugin exposes request fields as individual flags.
• For object-valued index parameters, write compact JSON to files and pass them with $(cat ...), for example --line "$(cat /tmp/sls-index-line.json)" and --keys "$(cat /tmp/sls-index-keys.json)".
• Pass scalar body properties directly, for example --max-text-len 2048, --scan-index true, or --log-reduce false.

---

Index Configuration Schema

The same JSON object is shared by CreateIndex, UpdateIndex, and the response of GetIndex.

IndexKey (entry value of keys)

IndexJsonKey (entry value of json_keys)

IndexJsonKey does not support its own token; text leaves use the parent json field's tokenizer.

Minimum example — full-text only

{
  "line": {
    "chn": false,
    "caseSensitive": false,
    "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
  }
}

Mixed example — full-text + field index

{
  "line": {
    "chn": false,
    "caseSensitive": false,
    "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", "?", "&", "/", ":", "\n", "\t", "\r"]
  },
  "keys": {
    "status": { "type": "long", "doc_value": true },
    "request_time": { "type": "double", "doc_value": true },
    "request_uri": {
      "type": "text",
      "doc_value": true,
      "caseSensitive": false,
      "chn": false,
      "token": [",", " ", ";", "=", "(", ")", "[", "]", "{", "}", ":", "/", "\n", "\t", "\r"]
    },
    "extra": {
      "type": "json",
      "doc_value": true,
      "index_all": true,
      "max_depth": 4
    }
  },
  "max_text_len": 2048
}

---

GetIndex

GET /logstores/{logstore}/index — invoke via aliyun sls get-index.

Input — Required

Output

The full index configuration object (see schema above) plus response-only fields ttl, index_mode, lastModifyTime, storage.

Common Errors

---

CreateIndex

POST /logstores/{logstore}/index — invoke via aliyun sls create-index.

Input — Required

Input — Optional (effectively required: at least one of line / keys / scan_index must be present in the body)

Common Errors

---

UpdateIndex

PUT /logstores/{logstore}/index — invoke via aliyun sls update-index.

Input — Required

Same as CreateIndex.

Body Semantics — Replace Full Config

The request body replaces the entire index configuration. Any field not included in the body is dropped. Treat update-index like create-index against an existing Logstore: prepare the complete final config, then submit it.

Call get-index first when you need a backup or a reference for the existing config.

Common Errors

Same set as CreateIndex, plus:

---

DeleteIndex

DELETE /logstores/{logstore}/index — invoke via aliyun sls delete-index.

Input — Required

Effect & Risk

• Removes all field indexes and full-text indexes; query / SQL / SPL on this Logstore will stop working.
• The deletion takes effect within ~1 minute; in-flight queries may continue to succeed during the propagation window.
• Always confirm with the user before invoking. This skill never chains delete-index after another write.

Common Errors

Reference Documentation