Create index API

Each index created can have specific settings associated with it, defined in the body:

resp = client.indices.create(
    index="my-index-000001",
    settings={
        "index": {
            "number_of_shards": 3,
            "number_of_replicas": 2
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my-index-000001',
  body: {
    settings: {
      index: {
        number_of_shards: 3,
        number_of_replicas: 2
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-index-000001",
  settings: {
    index: {
      number_of_shards: 3,
      number_of_replicas: 2,
    },
  },
});
console.log(response);

PUT /my-index-000001
{
  "settings": {
    "index": {
      "number_of_shards": 3,  
      "number_of_replicas": 2 
    }
  }
}

or more simplified

resp = client.indices.create(
    index="my-index-000001",
    settings={
        "number_of_shards": 3,
        "number_of_replicas": 2
    },
)
print(resp)

response = client.indices.create(
  index: 'my-index-000001',
  body: {
    settings: {
      number_of_shards: 3,
      number_of_replicas: 2
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my-index-000001",
  settings: {
    number_of_shards: 3,
    number_of_replicas: 2,
  },
});
console.log(response);

PUT /my-index-000001
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 2
  }
}

For more information regarding all the different index level settings that can be set when creating an index, please check the index modules section.

The create index API allows for providing a mapping definition:

resp = client.indices.create(
    index="test",
    settings={
        "number_of_shards": 1
    },
    mappings={
        "properties": {
            "field1": {
                "type": "text"
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'test',
  body: {
    settings: {
      number_of_shards: 1
    },
    mappings: {
      properties: {
        "field1": {
          type: 'text'
        }
      }
    }
  }
)
puts response

res, err := es.Indices.Create(
	"test",
	es.Indices.Create.WithBody(strings.NewReader(`{
	  "settings": {
	    "number_of_shards": 1
	  },
	  "mappings": {
	    "properties": {
	      "field1": {
	        "type": "text"
	      }
	    }
	  }
	}`)),
)
fmt.Println(res, err)

const response = await client.indices.create({
  index: "test",
  settings: {
    number_of_shards: 1,
  },
  mappings: {
    properties: {
      field1: {
        type: "text",
      },
    },
  },
});
console.log(response);

PUT /test
{
  "settings": {
    "number_of_shards": 1
  },
  "mappings": {
    "properties": {
      "field1": { "type": "text" }
    }
  }
}

The create index API allows also to provide a set of aliases:

resp = client.indices.create(
    index="test",
    aliases={
        "alias_1": {},
        "alias_2": {
            "filter": {
                "term": {
                    "user.id": "kimchy"
                }
            },
            "routing": "shard-1"
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'test',
  body: {
    aliases: {
      "alias_1": {},
      "alias_2": {
        filter: {
          term: {
            'user.id' => 'kimchy'
          }
        },
        routing: 'shard-1'
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "test",
  aliases: {
    alias_1: {},
    alias_2: {
      filter: {
        term: {
          "user.id": "kimchy",
        },
      },
      routing: "shard-1",
    },
  },
});
console.log(response);

PUT /test
{
  "aliases": {
    "alias_1": {},
    "alias_2": {
      "filter": {
        "term": { "user.id": "kimchy" }
      },
      "routing": "shard-1"
    }
  }
}

Index alias names also support date math.

resp = client.indices.create(
    index="logs",
    aliases={
        "<logs_{now/M}>": {}
    },
)
print(resp)

response = client.indices.create(
  index: 'logs',
  body: {
    aliases: {
      "<logs_{now/M}>": {}
    }
  }
)
puts response

const response = await client.indices.create({
  index: "logs",
  aliases: {
    "<logs_{now/M}>": {},
  },
});
console.log(response);

PUT /logs
{
  "aliases": {
    "<logs_{now/M}>": {}
  }
}

By default, index creation will only return a response to the client when the primary copies of each shard have been started, or the request times out. The index creation response will indicate what happened:

{
  "acknowledged": true,
  "shards_acknowledged": true,
  "index": "logs"
}

acknowledged indicates whether the index was successfully created in the cluster, while shards_acknowledged indicates whether the requisite number of shard copies were started for each shard in the index before timing out. Note that it is still possible for either acknowledged or shards_acknowledged to be false, but the index creation was successful. These values simply indicate whether the operation completed before the timeout. If acknowledged is false, then we timed out before the cluster state was updated with the newly created index, but it probably will be created sometime soon. If shards_acknowledged is false, then we timed out before the requisite number of shards were started (by default just the primaries), even if the cluster state was successfully updated to reflect the newly created index (i.e. acknowledged=true).

We can change the default of only waiting for the primary shards to start through the index setting index.write.wait_for_active_shards (note that changing this setting will also affect the wait_for_active_shards value on all subsequent write operations):

resp = client.indices.create(
    index="test",
    settings={
        "index.write.wait_for_active_shards": "2"
    },
)
print(resp)

response = client.indices.create(
  index: 'test',
  body: {
    settings: {
      'index.write.wait_for_active_shards' => '2'
    }
  }
)
puts response

res, err := es.Indices.Create(
	"test",
	es.Indices.Create.WithBody(strings.NewReader(`{
	  "settings": {
	    "index.write.wait_for_active_shards": "2"
	  }
	}`)),
)
fmt.Println(res, err)

const response = await client.indices.create({
  index: "test",
  settings: {
    "index.write.wait_for_active_shards": "2",
  },
});
console.log(response);

PUT /test
{
  "settings": {
    "index.write.wait_for_active_shards": "2"
  }
}

or through the request parameter wait_for_active_shards:

$params = [
    'index' => 'test',
];
$response = $client->indices()->create($params);

resp = client.indices.create(
    index="test",
    wait_for_active_shards="2",
)
print(resp)

response = client.indices.create(
  index: 'test',
  wait_for_active_shards: 2
)
puts response

res, err := es.Indices.Create("test?wait_for_active_shards=2")
fmt.Println(res, err)

const response = await client.indices.create({
  index: "test",
  wait_for_active_shards: 2,
});
console.log(response);

PUT /test?wait_for_active_shards=2

A detailed explanation of wait_for_active_shards and its possible values can be found here.