一键搭建 es + kibana

于 2025-05-02 21:12:55 发布
阅读量719 收藏 1
点赞数 9
分类专栏： Go-ES 文章标签： elasticsearch 大数据 搜索引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73516381/article/details/147672164
版权

一键搭建 es + kibana

bash 命令 docker 一键部署 es + kibana

为方便部署单机 es，写了个 bash 脚本

#!/bin/bash

# Record start time
START_TIME=$(date +%s)

# Normalize paths
normalize_paths() {
    SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
    if [[ "$BASE_DIR" == ./* ]]; then
        BASE_DIR="${SCRIPT_DIR}/${BASE_DIR#./}"
    elif [[ "$BASE_DIR" != /* ]]; then
        BASE_DIR="${SCRIPT_DIR}/${BASE_DIR}"
    fi
}

# Color output functions
print_green() { echo -e "\033[32m$1\033[0m"; }
print_yellow() { echo -e "\033[33m$1\033[0m"; }
print_red() { echo -e "\033[31m$1\033[0m"; }
print_blue() { echo -e "\033[34m$1\033[0m"; }

# Check directory permissions
check_directory_permissions() {
    TEST_DIR="./elastic-stack-test"
    mkdir -p "$TEST_DIR" || return 1
    echo "test" > "$TEST_DIR/test.txt" || { rm -rf "$TEST_DIR"; return 1; }
    rm -rf "$TEST_DIR"
    return 0
}

# Execute permission check
if ! check_directory_permissions; then
    print_red "Script requires permission to create files and directories in the current directory."
    exit 1
fi

print_green "✅ Directory permission check passed"

# Check Docker installation
if ! command -v docker &> /dev/null; then
    print_red "Docker not detected, please install Docker first"
    exit 1
fi

# Check Docker Compose installation
if ! command -v docker compose &> /dev/null; then
    print_red "Docker Compose not detected, please install Docker Compose first"
    exit 1
fi

# Detect operating system and adapt
detect_os() {
    if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" || "$OSTYPE" == "win32" || "$OSTYPE" == "mingw"* ]]; then
        IS_WINDOWS=true
    else
        IS_WINDOWS=false
    fi
}

# Adapt path for Windows
adapt_path() {
    if [ "$IS_WINDOWS" = true ]; then
        BASE_DIR=$(echo "$BASE_DIR" | sed 's/\\/\//g')
        if [[ "$BASE_DIR" =~ ^[A-Za-z]: ]]; then
            BASE_DIR="./${BASE_DIR#?:}"
        fi
    fi
}

# Detect OS
detect_os

# Configuration parameters
ES_VERSION="8.12.2"
ES_PASSWORD="elastic_password"
KIBANA_PORT=5601
ES_PORT=9200
BASE_DIR="./elastic-stack"

# Adapt and normalize paths
adapt_path
normalize_paths

# Ask for custom password
read -p "Set custom password? (y/n, default n): " SET_CUSTOM_PASSWORD
if [[ $SET_CUSTOM_PASSWORD == "y" || $SET_CUSTOM_PASSWORD == "Y" ]]; then
    read -s -p "Enter Elasticsearch password: " CUSTOM_PASSWORD
    echo
    if [[ ${#CUSTOM_PASSWORD} -lt 6 ]]; then
        print_red "Password must be at least 6 characters"
        exit 1
    fi
    ES_PASSWORD=$CUSTOM_PASSWORD
    print_green "✅ Custom password set"
else
    print_yellow "Using default password: elastic_password"
fi

print_blue "====== Elasticsearch + Kibana Deployment Started ======"

# Create necessary directories
mkdir -p ${BASE_DIR}/elasticsearch/data
mkdir -p ${BASE_DIR}/elasticsearch/plugins
mkdir -p ${BASE_DIR}/kibana/config

# Validate directory creation
if [ ! -d "${BASE_DIR}/kibana/config" ]; then
    ABSOLUTE_BASE_DIR="$(pwd)/${BASE_DIR}"
    mkdir -p "${ABSOLUTE_BASE_DIR}/kibana/config"
    if [ -d "${ABSOLUTE_BASE_DIR}/kibana/config" ]; then
        BASE_DIR="${ABSOLUTE_BASE_DIR}"
    else
        print_red "Directory creation failed, check permissions and disk space"
        exit 1
    fi
fi

# Set directory permissions
if [ "$(uname)" = "Linux" ]; then
    chmod -R 777 ${BASE_DIR}/elasticsearch/data
    chmod -R 777 ${BASE_DIR}/elasticsearch/plugins
    chown -R 1000:1000 ${BASE_DIR}/elasticsearch/data || true
    chown -R 1000:1000 ${BASE_DIR}/elasticsearch/plugins || true
fi

# Generate Docker Compose file
print_yellow "Configuring Elasticsearch password: $ES_PASSWORD"

# Check if Windows environment for volume strategy
USE_NAMED_VOLUMES=false
if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "cygwin" || "$OSTYPE" == "win32" ]]; then
    USE_NAMED_VOLUMES=true
fi

# Create Docker Compose file with appropriate volume strategy
if [ "$USE_NAMED_VOLUMES" = true ]; then
    cat > ${BASE_DIR}/docker-compose.yml << EOF
version: "3.1"
services:
  elasticsearch:
    container_name: es02
    image: elasticsearch:${ES_VERSION}
    restart: unless-stopped
    environment:
      - "ES_JAVA_OPTS=-Xms1024m -Xmx1024m"
      - "TZ=Asia/Shanghai"
      - "discovery.type=single-node"
      - "ELASTIC_PASSWORD=${ES_PASSWORD}"
      - "xpack.security.enabled=true"
      - "xpack.security.authc.api_key.enabled=true"
      - "xpack.security.authc.token.enabled=true"
      - "bootstrap.memory_lock=true"
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - "${ES_PORT}:9200"
      - "9300:9300"
    volumes:
      - esdata:/usr/share/elasticsearch/data
      - esplugins:/usr/share/elasticsearch/plugins
    networks:
      - elastic_net
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9200"]
      interval: 30s
      timeout: 10s
      retries: 5

  kibana:
    container_name: kibana02
    image: kibana:${ES_VERSION}
    restart: unless-stopped
    volumes:
      - ./kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml
    environment:
      - "TZ=Asia/Shanghai"
      - "I18N_LOCALE=zh-CN"
      - "ELASTICSEARCH_HOSTS=http://elasticsearch:9200"
    ports:
      - "${KIBANA_PORT}:5601"
    networks:
      - elastic_net
    depends_on:
      - elasticsearch

networks:
  elastic_net:
    driver: bridge

volumes:
  esdata:
    driver: local
  esplugins:
    driver: local
EOF
else
    cat > ${BASE_DIR}/docker-compose.yml << EOF
version: "3.1"
services:
  elasticsearch:
    container_name: es02
    image: elasticsearch:${ES_VERSION}
    restart: unless-stopped
    environment:
      - "ES_JAVA_OPTS=-Xms1024m -Xmx1024m"
      - "TZ=Asia/Shanghai"
      - "discovery.type=single-node"
      - "ELASTIC_PASSWORD=${ES_PASSWORD}"
      - "xpack.security.enabled=true"
      - "xpack.security.authc.api_key.enabled=true"
      - "xpack.security.authc.token.enabled=true"
      - "bootstrap.memory_lock=true"
    ulimits:
      memlock:
        soft: -1
        hard: -1
      nofile:
        soft: 65536
        hard: 65536
    ports:
      - "${ES_PORT}:9200"
      - "9300:9300"
    volumes:
      - ./elasticsearch/data:/usr/share/elasticsearch/data
      - ./elasticsearch/plugins:/usr/share/elasticsearch/plugins
    networks:
      - elastic_net
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9200"]
      interval: 30s
      timeout: 10s
      retries: 5

  kibana:
    container_name: kibana02
    image: kibana:${ES_VERSION}
    restart: unless-stopped
    volumes:
      - ./kibana/config/kibana.yml:/usr/share/kibana/config/kibana.yml
    environment:
      - "TZ=Asia/Shanghai"
      - "I18N_LOCALE=zh-CN"
      - "ELASTICSEARCH_HOSTS=http://elasticsearch:9200"
    ports:
      - "${KIBANA_PORT}:5601"
    networks:
      - elastic_net
    depends_on:
      - elasticsearch

networks:
  elastic_net:
    driver: bridge
EOF
fi

# Generate initial Kibana config
cat > ${BASE_DIR}/kibana/config/kibana.yml << EOF
server.name: kibana
server.host: 0.0.0.0
elasticsearch.hosts: [ "http://elasticsearch:9200" ]

# Temporary config - will be updated after Elasticsearch starts

# Localization
i18n.locale: "zh-CN"

# Disable telemetry
telemetry.enabled: false
EOF

# Start Elasticsearch
cd ${BASE_DIR}
docker compose up -d elasticsearch

# Wait for Elasticsearch to start
print_yellow "Waiting for Elasticsearch to start (may take a minute)..."
MAX_RETRIES=60
RETRY_COUNT=0

while [ $RETRY_COUNT -lt $MAX_RETRIES ]; do
    if curl --output /dev/null --silent --head --fail --max-time 5 -u elastic:${ES_PASSWORD} http://localhost:${ES_PORT}; then
        break
    else
        RETRY_COUNT=$((RETRY_COUNT+1))
        sleep 2
    fi
    
    if [ $RETRY_COUNT -eq $((MAX_RETRIES/2)) ]; then
        if ! docker ps | grep -q es02; then
            print_red "Error: Elasticsearch container not running. Check Docker logs."
            docker logs es02
            exit 1
        fi
    fi
done

if [ $RETRY_COUNT -eq $MAX_RETRIES ]; then
    print_red "Error: Timeout waiting for Elasticsearch to start."
    docker logs es02
    exit 1
fi

print_green "✅ Elasticsearch started successfully!"

# Flag to track token acquisition
KIBANA_TOKEN_ACQUIRED=false

# Create service account token for Kibana
print_yellow "Creating service account token for Kibana..."
TOKEN_NAME="kibana-token-$(date +%s)"
TOKEN_OUTPUT=$(docker exec es02 /bin/bash -c "bin/elasticsearch-service-tokens create elastic/kibana ${TOKEN_NAME}" 2>&1)
KIBANA_TOKEN=$(echo "$TOKEN_OUTPUT" | grep -oP "SERVICE_TOKEN elastic/kibana/${TOKEN_NAME} = \K.*")

if [ -n "$KIBANA_TOKEN" ]; then
    print_green "✅ Kibana service token created successfully"
    KIBANA_TOKEN_ACQUIRED=true
    
    # Create necessary roles and mappings
    docker exec es02 curl -s -X POST "http://localhost:9200/_security/role/kibana_system_role" \
        -H "Content-Type: application/json" \
        -u elastic:${ES_PASSWORD} \
        -d '{"cluster":["monitor","manage_index_templates","manage_ilm"],"indices":[{"names":[".kibana*",".reporting*"],"privileges":["all"]}]}' > /dev/null
    
    docker exec es02 curl -s -X POST "http://localhost:9200/_security/role_mapping/service_account_kibana_mapping" \
        -H "Content-Type: application/json" \
        -u elastic:${ES_PASSWORD} \
        -d '{"roles":["kibana_system","kibana_system_role"],"enabled":true,"rules":{"field":{"username":"elastic/kibana"}}}' > /dev/null
else
    # Try alternative method
    TOKEN_NAME="kibana-token2-$(date +%s)"
    TOKEN_OUTPUT=$(docker exec es02 /bin/bash -c "bin/elasticsearch-service-tokens create elastic/kibana ${TOKEN_NAME}" 2>&1)
    KIBANA_TOKEN=$(echo "$TOKEN_OUTPUT" | grep -oP "SERVICE_TOKEN elastic/kibana/${TOKEN_NAME} = \K.*")
    
    if [ -n "$KIBANA_TOKEN" ]; then
        KIBANA_TOKEN_ACQUIRED=true
        
        docker exec es02 curl -s -X POST "http://localhost:9200/_security/role/kibana_system_role" \
            -H "Content-Type: application/json" \
            -u elastic:${ES_PASSWORD} \
            -d '{"cluster":["monitor","manage_index_templates","manage_ilm"],"indices":[{"names":[".kibana*",".reporting*"],"privileges":["all"]}]}' > /dev/null
        
        docker exec es02 curl -s -X POST "http://localhost:9200/_security/role_mapping/service_account_kibana_mapping" \
            -H "Content-Type: application/json" \
            -u elastic:${ES_PASSWORD} \
            -d '{"roles":["kibana_system","kibana_system_role"],"enabled":true,"rules":{"field":{"username":"elastic/kibana"}}}' > /dev/null
    else
        print_red "❌ Failed to create service account token"
        exit 1
    fi
fi

# Ensure token was acquired
if [ "$KIBANA_TOKEN_ACQUIRED" != "true" ]; then
    print_red "❌ Failed to acquire Kibana service account token"
    exit 1
fi

# Update Kibana config with service token
cat > ${BASE_DIR}/kibana/config/kibana.yml << EOF
server.name: kibana
server.host: 0.0.0.0
elasticsearch.hosts: [ "http://elasticsearch:9200" ]

# Service account token authentication
elasticsearch.serviceAccountToken: ${KIBANA_TOKEN}

# Localization
i18n.locale: "zh-CN"

# Disable telemetry
telemetry.enabled: false
EOF

# Ensure config file contains token
if ! grep -q "elasticsearch.serviceAccountToken:" "${BASE_DIR}/kibana/config/kibana.yml"; then
    print_red "❌ Kibana config not properly updated, attempting direct write..."
    echo "elasticsearch.serviceAccountToken: ${KIBANA_TOKEN}" >> ${BASE_DIR}/kibana/config/kibana.yml
fi

# Test authentication
AUTH_TEST=$(docker exec es02 curl -s -o /dev/null -w "%{http_code}" -H "Authorization: Bearer ${KIBANA_TOKEN}" http://localhost:9200/_security/_authenticate)

if [ "$AUTH_TEST" != "200" ]; then
    print_red "Service account token authentication failed (HTTP ${AUTH_TEST}), retrying..."
    
    # Retry role mapping
    docker exec es02 curl -s -X POST "http://localhost:9200/_security/role_mapping/service_account_kibana_mapping" \
        -H "Content-Type: application/json" \
        -u elastic:${ES_PASSWORD} \
        -d '{"roles":["kibana_system","kibana_system_role"],"enabled":true,"rules":{"field":{"username":"elastic/kibana"}}}' > /dev/null
    
    # Test again
    sleep 2
    AUTH_TEST=$(docker exec es02 curl -s -o /dev/null -w "%{http_code}" -H "Authorization: Bearer ${KIBANA_TOKEN}" http://localhost:9200/_security/_authenticate)
fi

# Final check before starting Kibana
print_yellow "Starting Kibana..."

# Verify config file has token
CONFIG_FILE="${BASE_DIR}/kibana/config/kibana.yml"
if [ ! -f "$CONFIG_FILE" ] || ! grep -q "elasticsearch.serviceAccountToken:" "$CONFIG_FILE" 2>/dev/null; then
    print_red "❌ Warning: Token not found in Kibana config, rewriting..."
    mkdir -p "$(dirname "$CONFIG_FILE")"
    cat > "$CONFIG_FILE" << EOF
server.name: kibana
server.host: 0.0.0.0
elasticsearch.hosts: [ "http://elasticsearch:9200" ]

# Service account token authentication
elasticsearch.serviceAccountToken: ${KIBANA_TOKEN}

# Localization
i18n.locale: "zh-CN"

# Disable telemetry
telemetry.enabled: false
EOF
    
    if grep -q "elasticsearch.serviceAccountToken:" "$CONFIG_FILE" 2>/dev/null; then
        print_green "✅ Token successfully written to config file"
    else
        print_red "❌ Token write failed"
    fi
fi

# Start Kibana
docker compose up -d kibana

# Verify Kibana connection
verify_kibana_connection() {
    sleep 10
    KIBANA_LOGS=$(docker logs kibana02 2>&1)
    if echo "$KIBANA_LOGS" | grep -q "security_exception: unable to authenticate"; then
        print_red "⚠️ Authentication problem detected: Kibana authentication failed"
        return 2
    elif echo "$KIBANA_LOGS" | grep -q "ERROR"; then
        print_yellow "⚠️ Errors found in Kibana logs but not authentication issues."
        return 2
    else
        print_green "✅ Kibana connection to Elasticsearch successful"
        return 0
    fi
}

verify_kibana_connection

# Verify password in config
ES_CONFIG_PASSWORD=$(grep "ELASTIC_PASSWORD" "${BASE_DIR}/docker-compose.yml" | grep -o "=[^\"]*" | cut -d= -f2)
if [ "$ES_CONFIG_PASSWORD" != "$ES_PASSWORD" ]; then
    print_red "⚠️ Warning: Password mismatch in config file"
    sed -i "s/ELASTIC_PASSWORD=[^\"]*\"/ELASTIC_PASSWORD=${ES_PASSWORD}\"/" "${BASE_DIR}/docker-compose.yml"
    print_green "✅ Config file updated, restart Elasticsearch to apply new password:"
    print_yellow "cd ${BASE_DIR} && docker compose restart elasticsearch"
fi

# Calculate deployment time
END_TIME=$(date +%s)
ELAPSED_TIME=$((END_TIME - START_TIME))
MINUTES=$((ELAPSED_TIME / 60))
SECONDS=$((ELAPSED_TIME % 60))

print_green "
================================================
🎉 Deployment complete! Services are running:
🔹 Elasticsearch: http://localhost:${ES_PORT}
   Username: elastic
   Password: ${ES_PASSWORD}

🔹 Kibana: http://localhost:${KIBANA_PORT}
   Authentication: Service Account Token
================================================
"

print_blue "Deployment time: ${MINUTES}m${SECONDS}s"

有任何问题欢迎反馈

Canal全家桶+MySQL+Elasticsearch+Kibana全量+实时增量收取数据
作者的博客园已搬家到CSDN，访问博客园主页将默认跳转至CSDN
11-16 2698
文章目录Canal全家桶+MySQL+Elasticsearch+Kibana二进制方式部署1.准备环境1）服务部署规划2）下载包3）创建服务父目录4）配置服务快速启动别名5）数据库创建账号并授权6）安装Java环境2.Canal-server1）解压2）配置3）启动3.Canal-adapter1）解压2）配置3）启动4.Canal-admin5.安装Elasticsearch1）解压2）配置3）启动6.安装Kibana1）解压2）配置3）启动4）创建索引8.插入数据并测试1）建库2）建表3）插入数据4）
Windows ELK8 测试: filebeat8+kakfa+logstash8+elasticsearch8+kibana8 搭建日志系统（二）之加密
qq_30540299的博客
08-01 382
Windows ELK8 测试: filebeat8+kakfa+logstash8+elasticsearch8+kibana8 搭建日志系统（二）之加密1、elasticsearch 配置xpack2、重置下xpack 中的elastic用户密码**【重置前要先关闭http ssl认证】**3、重置下xpack 中的kibana用户密码**【重置前要先关闭http ssl认证】**4、启用xpack的所有安全功能是为kibana生成一键接入token 使用的，5、生成kibana 密钥。
Filebeat+Kafka+Logstash+ElasticSearch+Kibana搭建完整版
goodtimeflying的博客
07-09 260
Filebeat是一个日志文件托运工具，在你的服务器上安装客户端后，filebeat会监控日志目录或者指定的日志文件，追踪读取这些文件（追踪文件的变化，不停的读） Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据 Logstash是一根具备实时数据传输能力的管道，负责将数据信息从管道的输入端传输到管道的输出端；与此同时这根管道还可以让你根据自己的需求在中间加上滤网，Logstash提供里很多功能强大的滤网以满足你的各种应用场景 ElasticSearch它提供了
docker-compose 一键安装es+kibana
weixin_42600175的博客
09-11 366
重启容器。
自动化搭建ELK（Elasticsearch + Logstash + Kibana）
阿澈不吃蒜的博客
04-20 236
此脚本仅适用于Debian或Ubuntu系统，并且可能需要根据您的环境进行修改。此外，该脚本还假设您的日志文件位于。因此您需要相应地更改Logstash配置文件以匹配您的日志文件位置。
K8S部署(Elasticsearch+Kibana+Fluentd)
liuchao666888的博客
10-26 5636
实验环境版本 Kubernetes：v1.14.1 Elasticsearch镜像：docker.elastic.co/elasticsearch/elasticsearch:7.6.2 Kibana 镜像：docker.elastic.co/kibana/kibana:7.6.2 Fluentd 镜像：quay.io/fluentd_elasticsearch/fluentd:v3.0.1 简介 1、Elasticsearch Elasticsearch 是一个实时的、分布式的可扩展的搜索引擎，允许进行
巧用Docker搭建ES+Head+Kibana
LeoByte的编程驿站
09-01 1344
先赞后看，养成习惯 ???? 欢迎微信关注：Java编程之道 每天进步一点点，沉淀技术分享知识。 Docker 搭建ES+Head+Kibana 纯手搭建，绝不留坑，一键启动，屡试不爽！???? 后面自己在学习ELK、EFK的知识，所以搭建一套稳定的测试环境是必不可少的环节。考虑到市面上很多ES环境搭建都是针对tar包等，搭建过程繁琐并且因为版本还会出现很多兼容性问题以及大家没有那么多cpu资源的窘境，所以为大家整理一份自己的搭建笔记，助你走上ES学习快车道。 特此说明：仅限于测试环境，生产环境慎用！ 前
5W字穿透 ELK（史上最全）：elasticsearch +logstash+kibana
架构师尼恩
09-26 4711
Elasticsearch 是一个分布式的开源搜索和分析引擎，在的基础上开发而成。Lucene 是开源的搜索引擎工具包，Elasticsearch 充分利用Lucene，并对其进行了扩展，使存储、索引、搜索都变得更快、更容易， 而最重要的是， 正如名字中的“ elastic ”所示， 一切都是灵活、有弹性的。而且，应用代码也不是必须用Java 书写才可以和Elasticsearc兼容，完全可以通过JSON 格式的HTTP 请求来进行索引、搜索和管理Elasticsearch 集群。
Docker之docker-compose一键部署 Elasticsearch Logstash Kibana
oschina_41731918的博客
02-24 3940
docker结合docker-compose一键部署elk
k8s部署EFK-elasticsearch+fluentd+kibana
qq_36200932的博客
03-07 5623
参考地址 https://kubernetes.io/docs/concepts/services-networking/service/#headless-services https://www.qikqiak.com/post/install-efk-stack-on-k8s/
Docker环境快速部署Elasticsearch+Kibana集群脚本指南
使用脚本化部署Elasticsearch和Kibana集群不仅能够提高部署效率，还能够通过Docker的可复现特性方便地搭建出一致的测试和开发环境。开发者和测试人员可以通过脚本快速建立与生产环境相似的环境，以便进行功能测试、...
Elasticsearch 入门系列 —— Elasticsearch & Kibana 8.15 安装部署
weixin_47391305的博客
11-04 1169
一文快速上手 Elasticsearch 8.x 版本的安装，Elasticsearch & Kibana 保姆式安装教程
EHR和oa系统增加elk日志系统全解析，elasticsearch+logstash+kibana+filebeat搭建elk日志系统
周大侠的博客
06-28 561
1、创建虚拟机 2、安装docker和docker-compose #docker安装 add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" apt-get update apt-get install docker-ce=5:19.03.11~3-0~ubuntu-xenial 编辑/etc/docker/daemon..
OpenGL-ES 学习(15) ----纹理
最新发布
小猪佩奇的博客
05-01 1157
现实生活中，纹理(Texture) 类似于游戏中皮肤的概念，最通常的作用是装饰3D物体，它像贴纸一样贴在物体的表面，丰富物体的表面和细节在OpenGL-ES开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器所以在OpenGL-ES中，纹理实际上是一个可以被采样的复杂数据集合，是GPU的图像数据结构，纹理分为 2D纹理、立方图纹理和 3D纹理2D纹理是OpenGL-ES中最常见和最常用的纹理形式，是一个表示图像数据的二维数组，纹理中一个单独的数据单元被称为纹素或者纹理像素立方图纹理(
使用listPersonalCertificates 命令列示WebSphere Application Server特定密钥库中的个人证书
openeis的专栏
05-01 765
下面是详细的实例步骤。F (Finish)C (Cancel)wsadmin>详细语法参考。
ElasticSearch深入解析（六）：集群核心配置
TracyCoder的博客
04-29 903
NIOFS（非阻塞文件系统）通常指基于非阻塞I/O（Non-blocking I/O）技术实现的文件系统或文件操作机制，其核心特点是允许在文件读写等操作过程中无需等待操作完成，即可继续处理其他任务，从而提升系统在高并发场景下的效率。mmapfs并非独立的物理文件系统，而是一种通过内存映射（Memory Mapping）技术实现的文件操作机制。它将磁盘文件的内容直接映射到进程的虚拟地址空间，使应用程序能像访问内存一样读写文件，无需显式执行I/O系统调用（如readwrite。
Elasticsearch 根据两个字段搜索
Elastic 中国社区官方博客
05-01 1034
探索通过两个字段进行搜索的技术，包括 multi-match 查询、bool 查询和查询时字段加权。想要获得 Elastic 认证？查看下一期的时间！Elasticsearch 拥有众多新功能，帮助你为你的用例构建最佳搜索解决方案。深入学习我们的，了解更多信息，开始，或立即在上尝试 Elastic。在 Elasticsearch 中跨多个字段进行搜索是许多应用中的常见需求。
【工具】Elasticsearch：强大的开源搜索与分析引擎
qq_40205510的博客
04-29 811
Elasticsearch是一个开源的分布式搜索和分析引擎，基于Apache Lucene构建。它能够近乎实时地存储、搜索和分析大量数据。最初由Shay Banon开发并于2010年发布，Elasticsearch如今已成为最受欢迎的企业搜索引擎之一。Elasticsearch是一个功能强大、灵活且可扩展的搜索和分析引擎，适用于各种数据密集型应用。无论是构建企业搜索解决方案、分析日志数据，还是创建复杂的分析仪表板，Elasticsearch都能提供强大的支持。
Prometheus使用Recoding Rules优化性能
04-29 526
通过PromQL可以实时对Prometheus中采集到的样本数据进行查询，聚合以及其它各种运算操作。而在某些PromQL较为复杂且计算量较大时，直接使用PromQL可能会导致Prometheus响应超时的情况。这时需要一种能够类似于后台批处理的机制能够在后台完成这些复杂运算的计算，对于使用者而言只需要查询这些运算结果即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值