How to fix ResourceAlreadyExistsException: index [index_name] already exists in Elasticsearch

# Using curl with HEAD request (returns 200 if exists, 404 if not)
curl -I "localhost:9200/my-index" -u "username:password"

# Using the indices.exists API
curl -X GET "localhost:9200/my-index" -u "username:password"

# List all indices to verify
curl -X GET "localhost:9200/_cat/indices?v" -u "username:password"

const { Client } = require('@elastic/elasticsearch');
const client = new Client({ node: 'http://localhost:9200' });

async function createIndexIfNotExists(indexName, settings) {
  try {
    const exists = await client.indices.exists({ index: indexName });

    if (!exists) {
      await client.indices.create({
        index: indexName,
        body: settings
      });
      console.log(`Index ${indexName} created successfully`);
    } else {
      console.log(`Index ${indexName} already exists, skipping creation`);
    }
  } catch (error) {
    console.error('Error checking/creating index:', error);
    throw error;
  }
}

// Usage
await createIndexIfNotExists('my-index', {
  settings: {
    number_of_shards: 1,
    number_of_replicas: 1
  },
  mappings: {
    properties: {
      title: { type: 'text' },
      timestamp: { type: 'date' }
    }
  }
});

from elasticsearch import Elasticsearch

es = Elasticsearch(['http://localhost:9200'])

def create_index_if_not_exists(index_name, settings):
    if not es.indices.exists(index=index_name):
        es.indices.create(index=index_name, body=settings)
        print(f"Index {index_name} created")
    else:
        print(f"Index {index_name} already exists, skipping")

# Usage
create_index_if_not_exists('my-index', {
    'settings': {
        'number_of_shards': 1,
        'number_of_replicas': 1
    },
    'mappings': {
        'properties': {
            'title': {'type': 'text'},
            'timestamp': {'type': 'date'}
        }
    }
})

from elasticsearch import Elasticsearch
from elasticsearch.exceptions import RequestError

es = Elasticsearch(['http://localhost:9200'])

def create_index_safe(index_name, settings):
    try:
        es.indices.create(index=index_name, body=settings)
        print(f"Index {index_name} created successfully")
    except RequestError as e:
        # Check if error is specifically "resource_already_exists_exception"
        if e.error == 'resource_already_exists_exception':
            print(f"Index {index_name} already exists, continuing...")
        else:
            # Re-raise other errors
            raise

# Usage
create_index_safe('my-index', {
    'settings': {
        'number_of_shards': 1,
        'number_of_replicas': 1
    }
})

async function createIndexSafe(client, indexName, settings) {
  try {
    await client.indices.create({
      index: indexName,
      body: settings
    });
    console.log(`Index ${indexName} created successfully`);
  } catch (error) {
    // Check if error is "resource_already_exists_exception"
    if (error.meta?.body?.error?.type === 'resource_already_exists_exception') {
      console.log(`Index ${indexName} already exists, continuing...`);
    } else {
      // Re-throw other errors
      throw error;
    }
  }
}

import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.ElasticsearchStatusException;
import org.elasticsearch.rest.RestStatus;

public void createIndexSafe(RestHighLevelClient client, String indexName) {
    CreateIndexRequest request = new CreateIndexRequest(indexName);

    try {
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("Index " + indexName + " created successfully");
    } catch (ElasticsearchStatusException e) {
        if (e.status() == RestStatus.BAD_REQUEST &&
            e.getMessage().contains("resource_already_exists_exception")) {
            System.out.println("Index " + indexName + " already exists, continuing...");
        } else {
            throw e;
        }
    } catch (IOException e) {
        throw new RuntimeException("Failed to create index", e);
    }
}

# Delete the existing index
curl -X DELETE "localhost:9200/my-index" -u "username:password"

# Create the new index
curl -X PUT "localhost:9200/my-index" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "settings": {
    "number_of_shards": 1,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "timestamp": { "type": "date" }
    }
  }
}
'

async function recreateIndex(client, indexName, settings) {
  const env = process.env.NODE_ENV || 'production';

  // Only allow in non-production environments
  if (env === 'production') {
    throw new Error('Cannot recreate index in production environment');
  }

  try {
    // Check if index exists
    const exists = await client.indices.exists({ index: indexName });

    if (exists) {
      console.warn(`Deleting existing index: ${indexName}`);
      await client.indices.delete({ index: indexName });
    }

    // Create new index
    await client.indices.create({
      index: indexName,
      body: settings
    });

    console.log(`Index ${indexName} recreated successfully`);
  } catch (error) {
    console.error('Error recreating index:', error);
    throw error;
  }
}

def recreate_index(es, index_name, settings, allow_production=False):
    import os

    env = os.getenv('ENVIRONMENT', 'production')

    if env == 'production' and not allow_production:
        raise Exception('Cannot recreate index in production')

    if es.indices.exists(index=index_name):
        print(f"Deleting existing index: {index_name}")
        es.indices.delete(index=index_name)

    es.indices.create(index=index_name, body=settings)
    print(f"Index {index_name} recreated successfully")

# Create an index template
curl -X PUT "localhost:9200/_index_template/my-template" -u "username:password" -H 'Content-Type: application/json' -d'
{
  "index_patterns": ["logs-*", "metrics-*"],
  "priority": 100,
  "template": {
    "settings": {
      "number_of_shards": 1,
      "number_of_replicas": 1,
      "index": {
        "refresh_interval": "5s"
      }
    },
    "mappings": {
      "properties": {
        "timestamp": {
          "type": "date"
        },
        "message": {
          "type": "text"
        },
        "level": {
          "type": "keyword"
        }
      }
    }
  }
}
'

# Now indices matching the pattern will use this template automatically
# when created (if auto-create is enabled)

#!/bin/bash
# setup-elasticsearch-indices.sh

ELASTICSEARCH_URL="http://localhost:9200"
INDICES=("logs-app" "metrics-app" "events-app")

for index in "${INDICES[@]}"; do
  # Check if index exists
  status_code=$(curl -s -o /dev/null -w "%{http_code}" -I "$ELASTICSEARCH_URL/$index")

  if [ $status_code -eq 404 ]; then
    echo "Creating index: $index"
    curl -X PUT "$ELASTICSEARCH_URL/$index" -H 'Content-Type: application/json' -d'
    {
      "settings": {
        "number_of_shards": 1,
        "number_of_replicas": 1
      }
    }
    '
    echo ""
  elif [ $status_code -eq 200 ]; then
    echo "Index $index already exists, skipping"
  else
    echo "Error checking index $index: HTTP $status_code"
    exit 1
  fi
done

echo "All indices verified/created successfully"

# terraform-elasticsearch.tf
resource "elasticsearch_index" "my_index" {
  name               = "my-index"
  number_of_shards   = 1
  number_of_replicas = 1

  # Terraform will check state and only create if doesn't exist
  lifecycle {
    prevent_destroy = true
  }

  mappings = <<EOF
{
  "properties": {
    "title": { "type": "text" },
    "timestamp": { "type": "date" }
  }
}
EOF
}