diff --git a/server/src/main/java/org/elasticsearch/cluster/DiffableUtils.java b/server/src/main/java/org/elasticsearch/cluster/DiffableUtils.java
index 65f52112cf6ce..ecc5121f201f7 100644
--- a/server/src/main/java/org/elasticsearch/cluster/DiffableUtils.java
+++ b/server/src/main/java/org/elasticsearch/cluster/DiffableUtils.java
@@ -32,6 +32,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -148,6 +149,15 @@ public static <K, T extends Diffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> r
         return new ImmutableOpenMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader));
     }
 
+    /**
+     * Returns an empty diff for the given key and value serializers
+     */
+    public static <K, T extends Diffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> emptyOpenMapDiff(KeySerializer<K> keySerializer,
+                                                                                                    ValueSerializer<K, T> valueSerializer) {
+        return new ImmutableOpenMapDiff<>(keySerializer, valueSerializer, Collections.emptyList(),
+            Collections.emptyMap(), Collections.emptyMap());
+    }
+
     /**
      * Loads an object that represents difference between two ImmutableOpenIntMaps of Diffable objects using Diffable proto object
      */
diff --git a/server/src/main/java/org/elasticsearch/cluster/metadata/ComponentTemplate.java b/server/src/main/java/org/elasticsearch/cluster/metadata/ComponentTemplate.java
new file mode 100644
index 0000000000000..2b160b1b2fb11
--- /dev/null
+++ b/server/src/main/java/org/elasticsearch/cluster/metadata/ComponentTemplate.java
@@ -0,0 +1,300 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.cluster.metadata;
+
+import org.elasticsearch.cluster.AbstractDiffable;
+import org.elasticsearch.cluster.Diff;
+import org.elasticsearch.common.Nullable;
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.bytes.BytesArray;
+import org.elasticsearch.common.compress.CompressedXContent;
+import org.elasticsearch.common.io.stream.StreamInput;
+import org.elasticsearch.common.io.stream.StreamOutput;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentFactory;
+import org.elasticsearch.common.xcontent.XContentHelper;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.common.xcontent.XContentType;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * A component template is a re-usable template as well as metadata about the template. Each
+ * component template is expected to be valid on its own. For example, if a component template
+ * contains a field "foo", it's expected to contain all the necessary settings/mappings/etc for the
+ * "foo" field. These component templates make up the individual pieces composing an index template.
+ */
+public class ComponentTemplate extends AbstractDiffable<ComponentTemplate> implements ToXContentObject {
+    private static final ParseField TEMPLATE = new ParseField("template");
+    private static final ParseField VERSION = new ParseField("version");
+    private static final ParseField METADATA = new ParseField("_meta");
+
+    @SuppressWarnings("unchecked")
+    private static final ConstructingObjectParser<ComponentTemplate, Void> PARSER =
+        new ConstructingObjectParser<>("component_template", false,
+            a -> new ComponentTemplate((Template) a[0], (Long) a[1], (Map<String, Object>) a[2]));
+
+    static {
+        PARSER.declareObject(ConstructingObjectParser.constructorArg(), Template.PARSER, TEMPLATE);
+        PARSER.declareLong(ConstructingObjectParser.optionalConstructorArg(), VERSION);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.map(), METADATA);
+    }
+
+    private final Template template;
+    @Nullable
+    private final Long version;
+    @Nullable
+    private final Map<String, Object> metadata;
+
+    static Diff<ComponentTemplate> readComponentTemplateDiffFrom(StreamInput in) throws IOException {
+        return AbstractDiffable.readDiffFrom(ComponentTemplate::new, in);
+    }
+
+    public static ComponentTemplate parse(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    public ComponentTemplate(Template template, @Nullable Long version, @Nullable Map<String, Object> metadata) {
+        this.template = template;
+        this.version = version;
+        this.metadata = metadata;
+    }
+
+    public ComponentTemplate(StreamInput in) throws IOException {
+        this.template = new Template(in);
+        this.version = in.readOptionalVLong();
+        if (in.readBoolean()) {
+            this.metadata = in.readMap();
+        } else {
+            this.metadata = null;
+        }
+    }
+
+    public Template template() {
+        return template;
+    }
+
+    @Nullable
+    public Long version() {
+        return version;
+    }
+
+    @Nullable
+    public Map<String, Object> metadata() {
+        return metadata;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        this.template.writeTo(out);
+        out.writeOptionalVLong(this.version);
+        if (this.metadata == null) {
+            out.writeBoolean(false);
+        } else {
+            out.writeBoolean(true);
+            out.writeMap(this.metadata);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(template, version, metadata);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj.getClass() != getClass()) {
+            return false;
+        }
+        ComponentTemplate other = (ComponentTemplate) obj;
+        return Objects.equals(template, other.template) &&
+            Objects.equals(version, other.version) &&
+            Objects.equals(metadata, other.metadata);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(this);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(TEMPLATE.getPreferredName(), this.template);
+        if (this.version != null) {
+            builder.field(VERSION.getPreferredName(), this.version);
+        }
+        if (this.metadata != null) {
+            builder.field(METADATA.getPreferredName(), this.metadata);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    static class Template extends AbstractDiffable<Template> implements ToXContentObject {
+        private static final ParseField SETTINGS = new ParseField("settings");
+        private static final ParseField MAPPINGS = new ParseField("mappings");
+        private static final ParseField ALIASES = new ParseField("aliases");
+
+        @SuppressWarnings("unchecked")
+        private static final ConstructingObjectParser<Template, Void> PARSER = new ConstructingObjectParser<>("template", false,
+            a -> new Template((Settings) a[0], (CompressedXContent) a[1], (Map<String, AliasMetaData>) a[2]));
+
+        static {
+            PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> Settings.fromXContent(p), SETTINGS);
+            PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) ->
+                new CompressedXContent(Strings.toString(XContentFactory.jsonBuilder().map(p.mapOrdered()))), MAPPINGS);
+            PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> {
+                Map<String, AliasMetaData> aliasMap = new HashMap<>();
+                while ((p.nextToken()) != XContentParser.Token.END_OBJECT) {
+                    AliasMetaData alias = AliasMetaData.Builder.fromXContent(p);
+                    aliasMap.put(alias.alias(), alias);
+                }
+                return aliasMap;
+            }, ALIASES);
+        }
+
+        @Nullable
+        private final Settings settings;
+        @Nullable
+        private final CompressedXContent mappings;
+        @Nullable
+        private final Map<String, AliasMetaData> aliases;
+
+        Template(@Nullable Settings settings, @Nullable CompressedXContent mappings, @Nullable Map<String, AliasMetaData> aliases) {
+            this.settings = settings;
+            this.mappings = mappings;
+            this.aliases = aliases;
+        }
+
+        Template(StreamInput in) throws IOException {
+            if (in.readBoolean()) {
+                this.settings = Settings.readSettingsFromStream(in);
+            } else {
+                this.settings = null;
+            }
+            if (in.readBoolean()) {
+                this.mappings = CompressedXContent.readCompressedString(in);
+            } else {
+                this.mappings = null;
+            }
+            if (in.readBoolean()) {
+                this.aliases = in.readMap(StreamInput::readString, AliasMetaData::new);
+            } else {
+                this.aliases = null;
+            }
+        }
+
+        public Settings settings() {
+            return settings;
+        }
+
+        public CompressedXContent mappings() {
+            return mappings;
+        }
+
+        public Map<String, AliasMetaData> aliases() {
+            return aliases;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            if (this.settings == null) {
+                out.writeBoolean(false);
+            } else {
+                out.writeBoolean(true);
+                Settings.writeSettingsToStream(this.settings, out);
+            }
+            if (this.mappings == null) {
+                out.writeBoolean(false);
+            } else {
+                out.writeBoolean(true);
+                this.mappings.writeTo(out);
+            }
+            if (this.aliases == null) {
+                out.writeBoolean(false);
+            } else {
+                out.writeBoolean(true);
+                out.writeMap(this.aliases, StreamOutput::writeString, (stream, aliasMetaData) -> aliasMetaData.writeTo(stream));
+            }
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(settings, mappings, aliases);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj == null) {
+                return false;
+            }
+            if (obj.getClass() != getClass()) {
+                return false;
+            }
+            Template other = (Template) obj;
+            return Objects.equals(settings, other.settings) &&
+                Objects.equals(mappings, other.mappings) &&
+                Objects.equals(aliases, other.aliases);
+        }
+
+        @Override
+        public String toString() {
+            return Strings.toString(this);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            if (this.settings != null) {
+                builder.startObject(SETTINGS.getPreferredName());
+                this.settings.toXContent(builder, params);
+                builder.endObject();
+            }
+            if (this.mappings != null) {
+                Map<String, Object> uncompressedMapping =
+                    XContentHelper.convertToMap(new BytesArray(this.mappings.uncompressed()), true, XContentType.JSON).v2();
+                if (uncompressedMapping.size() > 0) {
+                    builder.field(MAPPINGS.getPreferredName());
+                    builder.map(uncompressedMapping);
+                }
+            }
+            if (this.aliases != null) {
+                builder.startObject(ALIASES.getPreferredName());
+                for (AliasMetaData alias : this.aliases.values()) {
+                    AliasMetaData.Builder.toXContent(alias, builder, params);
+                }
+                builder.endObject();
+            }
+            builder.endObject();
+            return builder;
+        }
+    }
+}
diff --git a/server/src/main/java/org/elasticsearch/cluster/metadata/MetaData.java b/server/src/main/java/org/elasticsearch/cluster/metadata/MetaData.java
index 00d3a8d708d62..26de040dbb4f9 100644
--- a/server/src/main/java/org/elasticsearch/cluster/metadata/MetaData.java
+++ b/server/src/main/java/org/elasticsearch/cluster/metadata/MetaData.java
@@ -171,6 +171,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment {
     private final DiffableStringMap hashesOfConsistentSettings;
     private final ImmutableOpenMap<String, IndexMetaData> indices;
     private final ImmutableOpenMap<String, IndexTemplateMetaData> templates;
+    private final ImmutableOpenMap<String, ComponentTemplate> componentTemplates;
     private final ImmutableOpenMap<String, Custom> customs;
 
     private final transient int totalNumberOfShards; // Transient ? not serializable anyway?
@@ -188,7 +189,8 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment {
     MetaData(String clusterUUID, boolean clusterUUIDCommitted, long version, CoordinationMetaData coordinationMetaData,
              Settings transientSettings, Settings persistentSettings, DiffableStringMap hashesOfConsistentSettings,
              ImmutableOpenMap<String, IndexMetaData> indices, ImmutableOpenMap<String, IndexTemplateMetaData> templates,
-             ImmutableOpenMap<String, Custom> customs, String[] allIndices, String[] visibleIndices, String[] allOpenIndices,
+             ImmutableOpenMap<String, ComponentTemplate> componentTemplates, ImmutableOpenMap<String, Custom> customs,
+             String[] allIndices, String[] visibleIndices, String[] allOpenIndices,
              String[] visibleOpenIndices, String[] allClosedIndices, String[] visibleClosedIndices,
              SortedMap<String, AliasOrIndex> aliasAndIndexLookup) {
         this.clusterUUID = clusterUUID;
@@ -202,6 +204,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment {
         this.indices = indices;
         this.customs = customs;
         this.templates = templates;
+        this.componentTemplates = componentTemplates;
         int totalNumberOfShards = 0;
         int totalOpenIndexShards = 0;
         for (ObjectCursor<IndexMetaData> cursor : indices.values()) {
@@ -661,6 +664,10 @@ public ImmutableOpenMap<String, IndexTemplateMetaData> getTemplates() {
         return this.templates;
     }
 
+    public ImmutableOpenMap<String, ComponentTemplate> componentTemplates() {
+        return this.componentTemplates;
+    }
+
     public ImmutableOpenMap<String, Custom> customs() {
         return this.customs;
     }
@@ -755,6 +762,9 @@ public static boolean isGlobalStateEquals(MetaData metaData1, MetaData metaData2
         if (!metaData1.templates.equals(metaData2.templates())) {
             return false;
         }
+        if (!metaData1.componentTemplates.equals(metaData2.componentTemplates())) {
+            return false;
+        }
         if (!metaData1.clusterUUID.equals(metaData2.clusterUUID)) {
             return false;
         }
@@ -809,6 +819,7 @@ private static class MetaDataDiff implements Diff<MetaData> {
         private Diff<DiffableStringMap> hashesOfConsistentSettings;
         private Diff<ImmutableOpenMap<String, IndexMetaData>> indices;
         private Diff<ImmutableOpenMap<String, IndexTemplateMetaData>> templates;
+        private Diff<ImmutableOpenMap<String, ComponentTemplate>> componentTemplates;
         private Diff<ImmutableOpenMap<String, Custom>> customs;
 
         MetaDataDiff(MetaData before, MetaData after) {
@@ -821,6 +832,8 @@ private static class MetaDataDiff implements Diff<MetaData> {
             hashesOfConsistentSettings = after.hashesOfConsistentSettings.diff(before.hashesOfConsistentSettings);
             indices = DiffableUtils.diff(before.indices, after.indices, DiffableUtils.getStringKeySerializer());
             templates = DiffableUtils.diff(before.templates, after.templates, DiffableUtils.getStringKeySerializer());
+            componentTemplates = DiffableUtils.diff(before.componentTemplates,
+                after.componentTemplates, DiffableUtils.getStringKeySerializer());
             customs = DiffableUtils.diff(before.customs, after.customs, DiffableUtils.getStringKeySerializer(), CUSTOM_VALUE_SERIALIZER);
         }
 
@@ -840,6 +853,13 @@ private static class MetaDataDiff implements Diff<MetaData> {
                 IndexMetaData::readDiffFrom);
             templates = DiffableUtils.readImmutableOpenMapDiff(in, DiffableUtils.getStringKeySerializer(), IndexTemplateMetaData::readFrom,
                 IndexTemplateMetaData::readDiffFrom);
+            if (in.getVersion().onOrAfter(Version.V_8_0_0)) {
+                componentTemplates = DiffableUtils.readImmutableOpenMapDiff(in, DiffableUtils.getStringKeySerializer(),
+                    ComponentTemplate::new, ComponentTemplate::readComponentTemplateDiffFrom);
+            } else {
+                componentTemplates = DiffableUtils.emptyOpenMapDiff(DiffableUtils.getStringKeySerializer(),
+                    new DiffableUtils.DiffableValueReader<>(ComponentTemplate::new, ComponentTemplate::readComponentTemplateDiffFrom));
+            }
             customs = DiffableUtils.readImmutableOpenMapDiff(in, DiffableUtils.getStringKeySerializer(), CUSTOM_VALUE_SERIALIZER);
         }
 
@@ -856,6 +876,9 @@ public void writeTo(StreamOutput out) throws IOException {
             }
             indices.writeTo(out);
             templates.writeTo(out);
+            if (out.getVersion().onOrAfter(Version.V_8_0_0)) {
+                componentTemplates.writeTo(out);
+            }
             customs.writeTo(out);
         }
 
@@ -871,6 +894,7 @@ public MetaData apply(MetaData part) {
             builder.hashesOfConsistentSettings(hashesOfConsistentSettings.apply(part.hashesOfConsistentSettings));
             builder.indices(indices.apply(part.indices));
             builder.templates(templates.apply(part.templates));
+            builder.componentTemplates(componentTemplates.apply(part.componentTemplates));
             builder.customs(customs.apply(part.customs));
             return builder.build();
         }
@@ -895,6 +919,14 @@ public static MetaData readFrom(StreamInput in) throws IOException {
         for (int i = 0; i < size; i++) {
             builder.put(IndexTemplateMetaData.readFrom(in));
         }
+        if (in.getVersion().onOrAfter(Version.V_8_0_0)) {
+            int componentCount = in.readVInt();
+            for (int i = 0; i < componentCount; i++) {
+                String id = in.readString();
+                ComponentTemplate componentTemplate = new ComponentTemplate(in);
+                builder.put(id, componentTemplate);
+            }
+        }
         int customSize = in.readVInt();
         for (int i = 0; i < customSize; i++) {
             Custom customIndexMetaData = in.readNamedWriteable(Custom.class);
@@ -922,6 +954,13 @@ public void writeTo(StreamOutput out) throws IOException {
         for (ObjectCursor<IndexTemplateMetaData> cursor : templates.values()) {
             cursor.value.writeTo(out);
         }
+        if (out.getVersion().onOrAfter(Version.V_8_0_0)) {
+            out.writeVInt(componentTemplates.size());
+            for (ObjectObjectCursor<String, ComponentTemplate> cursor : componentTemplates) {
+                out.writeString(cursor.key);
+                cursor.value.writeTo(out);
+            }
+        }
         // filter out custom states not supported by the other node
         int numberOfCustoms = 0;
         for (final ObjectCursor<Custom> cursor : customs.values()) {
@@ -958,12 +997,14 @@ public static class Builder {
 
         private final ImmutableOpenMap.Builder<String, IndexMetaData> indices;
         private final ImmutableOpenMap.Builder<String, IndexTemplateMetaData> templates;
+        private final ImmutableOpenMap.Builder<String, ComponentTemplate> componentTemplates;
         private final ImmutableOpenMap.Builder<String, Custom> customs;
 
         public Builder() {
             clusterUUID = UNKNOWN_CLUSTER_UUID;
             indices = ImmutableOpenMap.builder();
             templates = ImmutableOpenMap.builder();
+            componentTemplates = ImmutableOpenMap.builder();
             customs = ImmutableOpenMap.builder();
             indexGraveyard(IndexGraveyard.builder().build()); // create new empty index graveyard to initialize
         }
@@ -978,6 +1019,7 @@ public Builder(MetaData metaData) {
             this.version = metaData.version;
             this.indices = ImmutableOpenMap.builder(metaData.indices);
             this.templates = ImmutableOpenMap.builder(metaData.templates);
+            this.componentTemplates = ImmutableOpenMap.builder(metaData.componentTemplates);
             this.customs = ImmutableOpenMap.builder(metaData.customs);
         }
 
@@ -1052,6 +1094,21 @@ public Builder templates(ImmutableOpenMap<String, IndexTemplateMetaData> templat
             return this;
         }
 
+        public Builder put(String name, ComponentTemplate componentTemplate) {
+            componentTemplates.put(name, componentTemplate);
+            return this;
+        }
+
+        public Builder removeComponentTemplate(String componentTemplate) {
+            componentTemplates.remove(componentTemplate);
+            return this;
+        }
+
+        public Builder componentTemplates(ImmutableOpenMap<String, ComponentTemplate> componentTemplates) {
+            this.componentTemplates.putAll(componentTemplates);
+            return this;
+        }
+
         public Custom getCustom(String type) {
             return customs.get(type);
         }
@@ -1241,8 +1298,9 @@ public MetaData build() {
             String[] visibleClosedIndicesArray = visibleClosedIndices.toArray(Strings.EMPTY_ARRAY);
 
             return new MetaData(clusterUUID, clusterUUIDCommitted, version, coordinationMetaData, transientSettings, persistentSettings,
-                hashesOfConsistentSettings, indices.build(), templates.build(), customs.build(), allIndicesArray, visibleIndicesArray,
-                allOpenIndicesArray, visibleOpenIndicesArray, allClosedIndicesArray, visibleClosedIndicesArray, aliasAndIndexLookup);
+                hashesOfConsistentSettings, indices.build(), templates.build(), componentTemplates.build(), customs.build(),
+                allIndicesArray, visibleIndicesArray, allOpenIndicesArray, visibleOpenIndicesArray, allClosedIndicesArray,
+                visibleClosedIndicesArray, aliasAndIndexLookup);
         }
 
         private SortedMap<String, AliasOrIndex> buildAliasAndIndexLookup() {
@@ -1309,6 +1367,12 @@ public static void toXContent(MetaData metaData, XContentBuilder builder, ToXCon
             }
             builder.endObject();
 
+            builder.startObject("component_templates");
+            for (ObjectObjectCursor<String, ComponentTemplate> cursor : metaData.componentTemplates()) {
+                builder.field(cursor.key, cursor.value);
+            }
+            builder.endObject();
+
             if (context == XContentContext.API && !metaData.indices().isEmpty()) {
                 builder.startObject("indices");
                 for (IndexMetaData indexMetaData : metaData) {
@@ -1372,6 +1436,11 @@ public static MetaData fromXContent(XContentParser parser, boolean preserveUnkno
                         while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                             builder.put(IndexTemplateMetaData.Builder.fromXContent(parser, parser.currentName()));
                         }
+                    } else if ("component_templates".equals(currentFieldName)) {
+                        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                            String name = parser.currentName();
+                            builder.put(name, ComponentTemplate.parse(parser));
+                        }
                     } else {
                         try {
                             Custom custom = parser.namedObject(Custom.class, currentFieldName, null);
diff --git a/server/src/test/java/org/elasticsearch/cluster/metadata/ComponentTemplateTests.java b/server/src/test/java/org/elasticsearch/cluster/metadata/ComponentTemplateTests.java
new file mode 100644
index 0000000000000..fa582ce1a6bf2
--- /dev/null
+++ b/server/src/test/java/org/elasticsearch/cluster/metadata/ComponentTemplateTests.java
@@ -0,0 +1,164 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.cluster.metadata;
+
+import org.elasticsearch.cluster.Diff;
+import org.elasticsearch.common.compress.CompressedXContent;
+import org.elasticsearch.common.io.stream.Writeable;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.common.xcontent.XContentParser;
+import org.elasticsearch.test.AbstractDiffableSerializationTestCase;
+import org.elasticsearch.test.ESTestCase;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+public class ComponentTemplateTests extends AbstractDiffableSerializationTestCase<ComponentTemplate> {
+    @Override
+    protected ComponentTemplate makeTestChanges(ComponentTemplate testInstance) {
+        try {
+            return mutateInstance(testInstance);
+        } catch (IOException e) {
+            logger.error(e);
+            fail("mutating should not throw an exception, but got: " + e);
+            return null;
+        }
+    }
+
+    @Override
+    protected Writeable.Reader<Diff<ComponentTemplate>> diffReader() {
+        return ComponentTemplate::readComponentTemplateDiffFrom;
+    }
+
+    @Override
+    protected ComponentTemplate doParseInstance(XContentParser parser) throws IOException {
+        return ComponentTemplate.parse(parser);
+    }
+
+    @Override
+    protected Writeable.Reader<ComponentTemplate> instanceReader() {
+        return ComponentTemplate::new;
+    }
+
+    @Override
+    protected ComponentTemplate createTestInstance() {
+        return randomInstance();
+    }
+
+    public static ComponentTemplate randomInstance() {
+        Settings settings = null;
+        CompressedXContent mappings = null;
+        Map<String, AliasMetaData> aliases = null;
+        if (randomBoolean()) {
+            settings = randomSettings();
+        }
+        if (randomBoolean()) {
+            mappings = randomMappings();
+        }
+        if (randomBoolean()) {
+            aliases = randomAliases();
+        }
+        ComponentTemplate.Template template = new ComponentTemplate.Template(settings, mappings, aliases);
+
+        Map<String, Object> meta = null;
+        if (randomBoolean()) {
+            meta = randomMeta();
+        }
+        return new ComponentTemplate(template, randomBoolean() ? null : randomNonNegativeLong(), meta);
+    }
+
+    private static Map<String, AliasMetaData> randomAliases() {
+        String aliasName = randomAlphaOfLength(5);
+        AliasMetaData aliasMeta = AliasMetaData.builder(aliasName)
+            .filter(Collections.singletonMap(randomAlphaOfLength(2), randomAlphaOfLength(2)))
+            .routing(randomBoolean() ? null : randomAlphaOfLength(3))
+            .isHidden(randomBoolean() ? null : randomBoolean())
+            .writeIndex(randomBoolean() ? null : randomBoolean())
+            .build();
+        return Collections.singletonMap(aliasName, aliasMeta);
+    }
+
+    private static CompressedXContent randomMappings() {
+        try {
+            return new CompressedXContent("{\"" + randomAlphaOfLength(3) + "\":\"" + randomAlphaOfLength(7) + "\"}");
+        } catch (IOException e) {
+            fail("got an IO exception creating fake mappings: " + e);
+            return null;
+        }
+    }
+
+    private static Settings randomSettings() {
+        return Settings.builder()
+            .put(randomAlphaOfLength(4), randomAlphaOfLength(10))
+            .build();
+    }
+
+    private static Map<String, Object> randomMeta() {
+        if (randomBoolean()) {
+            return Collections.singletonMap(randomAlphaOfLength(4), randomAlphaOfLength(4));
+        } else {
+            return Collections.singletonMap(randomAlphaOfLength(5),
+                Collections.singletonMap(randomAlphaOfLength(4), randomAlphaOfLength(4)));
+        }
+    }
+
+    @Override
+    protected ComponentTemplate mutateInstance(ComponentTemplate orig) throws IOException {
+        switch (randomIntBetween(0, 2)) {
+            case 0:
+                switch (randomIntBetween(0, 2)) {
+                    case 0:
+                        ComponentTemplate.Template ot = orig.template();
+                        return new ComponentTemplate(
+                            new ComponentTemplate.Template(randomValueOtherThan(ot.settings(), ComponentTemplateTests::randomSettings),
+                                ot.mappings(), ot.aliases()),
+                            orig.version(), orig.metadata());
+                    case 1:
+                        ComponentTemplate.Template ot2 = orig.template();
+                        return new ComponentTemplate(
+                            new ComponentTemplate.Template(ot2.settings(),
+                                randomValueOtherThan(ot2.mappings(), ComponentTemplateTests::randomMappings), ot2.aliases()),
+                            orig.version(), orig.metadata());
+                    case 2:
+                        ComponentTemplate.Template ot3 = orig.template();
+                        return new ComponentTemplate(
+                            new ComponentTemplate.Template(ot3.settings(), ot3.mappings(),
+                                randomValueOtherThan(ot3.aliases(), ComponentTemplateTests::randomAliases)),
+                            orig.version(), orig.metadata());
+                    default:
+                        throw new IllegalStateException("illegal randomization branch");
+                }
+            case 1:
+                return new ComponentTemplate(orig.template(), randomValueOtherThan(orig.version(), ESTestCase::randomNonNegativeLong),
+                    orig.metadata());
+            case 2:
+                return new ComponentTemplate(orig.template(), orig.version(),
+                    randomValueOtherThan(orig.metadata(), ComponentTemplateTests::randomMeta));
+            default:
+                throw new IllegalStateException("illegal randomization branch");
+        }
+    }
+
+    @Override
+    protected void assertEqualInstances(ComponentTemplate expectedInstance, ComponentTemplate newInstance) {
+        super.assertEqualInstances(expectedInstance, newInstance);
+    }
+}
diff --git a/server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataTests.java b/server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataTests.java
index 5bd981f246a56..1d0bd3e36c57b 100644
--- a/server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataTests.java
+++ b/server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataTests.java
@@ -44,6 +44,7 @@
 import org.elasticsearch.test.ESTestCase;
 
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -723,7 +724,7 @@ public void testFindMappingsWithFilters() throws IOException {
         }
     }
 
-    private IndexMetaData.Builder buildIndexMetaData(String name, String alias, Boolean writeIndex) {
+    private static IndexMetaData.Builder buildIndexMetaData(String name, String alias, Boolean writeIndex) {
         return IndexMetaData.builder(name)
             .settings(settings(Version.CURRENT)).creationDate(randomNonNegativeLong())
             .putAlias(AliasMetaData.builder(alias).writeIndex(writeIndex))
@@ -906,4 +907,37 @@ public void testBuilderRejectsNullInCustoms() {
         final ImmutableOpenMap<String, MetaData.Custom> map = mapBuilder.build();
         assertThat(expectThrows(NullPointerException.class, () -> builder.customs(map)).getMessage(), containsString(key));
     }
+
+    public void testSerialization() throws IOException {
+        final MetaData orig = randomMetaData();
+        final BytesStreamOutput out = new BytesStreamOutput();
+        orig.writeTo(out);
+        NamedWriteableRegistry namedWriteableRegistry = new NamedWriteableRegistry(ClusterModule.getNamedWriteables());
+        final MetaData fromStreamMeta = MetaData.readFrom(new NamedWriteableAwareStreamInput(out.bytes().streamInput(),
+            namedWriteableRegistry));
+        assertTrue(MetaData.isGlobalStateEquals(orig, fromStreamMeta));
+    }
+
+    public static MetaData randomMetaData() {
+        return MetaData.builder()
+            .put(buildIndexMetaData("index", "alias", randomBoolean() ? null : randomBoolean()).build(), randomBoolean())
+            .put(IndexTemplateMetaData.builder("template" + randomAlphaOfLength(3))
+                .patterns(Arrays.asList("bar-*", "foo-*"))
+                .settings(Settings.builder()
+                    .put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+                    .build())
+                .build())
+            .persistentSettings(Settings.builder()
+                .put("setting" + randomAlphaOfLength(3), randomAlphaOfLength(4))
+                .build())
+            .transientSettings(Settings.builder()
+                .put("other_setting" + randomAlphaOfLength(3), randomAlphaOfLength(4))
+                .build())
+            .clusterUUID("uuid" + randomAlphaOfLength(3))
+            .clusterUUIDCommitted(randomBoolean())
+            .indexGraveyard(IndexGraveyardTests.createRandom())
+            .version(randomNonNegativeLong())
+            .put("component_template_" + randomAlphaOfLength(3), ComponentTemplateTests.randomInstance())
+            .build();
+    }
 }
diff --git a/server/src/test/java/org/elasticsearch/cluster/metadata/ToAndFromJsonMetaDataTests.java b/server/src/test/java/org/elasticsearch/cluster/metadata/ToAndFromJsonMetaDataTests.java
index 0338a64b6fe7e..b03c41484893f 100644
--- a/server/src/test/java/org/elasticsearch/cluster/metadata/ToAndFromJsonMetaDataTests.java
+++ b/server/src/test/java/org/elasticsearch/cluster/metadata/ToAndFromJsonMetaDataTests.java
@@ -20,6 +20,7 @@
 package org.elasticsearch.cluster.metadata;
 
 import org.elasticsearch.Version;
+import org.elasticsearch.common.compress.CompressedXContent;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.json.JsonXContent;
 import org.elasticsearch.test.ESTestCase;
@@ -116,6 +117,11 @@ public void testSimpleJsonFromAndTo() throws IOException {
                         .putAlias(newAliasMetaDataBuilder("alias-bar1"))
                         .putAlias(newAliasMetaDataBuilder("alias-bar2").filter("{\"term\":{\"user\":\"kimchy\"}}"))
                         .putAlias(newAliasMetaDataBuilder("alias-bar3").routing("routing-bar")))
+                .put("component_template", new ComponentTemplate(
+                    new ComponentTemplate.Template(Settings.builder().put("setting", "value").build(),
+                        new CompressedXContent("{\"baz\":\"eggplant\"}"),
+                        Collections.singletonMap("alias", AliasMetaData.builder("alias").build())),
+                    5L, Collections.singletonMap("my_meta", Collections.singletonMap("foo", "bar"))))
                 .put(IndexMetaData.builder("test12")
                         .settings(settings(Version.CURRENT)
                                 .put("setting1", "value1")
@@ -285,6 +291,16 @@ public void testSimpleJsonFromAndTo() throws IOException {
         assertThat(parsedMetaData.templates().get("foo").aliases().get("alias-bar3").alias(), equalTo("alias-bar3"));
         assertThat(parsedMetaData.templates().get("foo").aliases().get("alias-bar3").indexRouting(), equalTo("routing-bar"));
         assertThat(parsedMetaData.templates().get("foo").aliases().get("alias-bar3").searchRouting(), equalTo("routing-bar"));
+
+        // component template
+        assertNotNull(parsedMetaData.componentTemplates().get("component_template"));
+        assertThat(parsedMetaData.componentTemplates().get("component_template").version(), is(5L));
+        assertThat(parsedMetaData.componentTemplates().get("component_template").metadata(),
+            equalTo(Collections.singletonMap("my_meta", Collections.singletonMap("foo", "bar"))));
+        assertThat(parsedMetaData.componentTemplates().get("component_template").template(),
+            equalTo(new ComponentTemplate.Template(Settings.builder().put("setting", "value").build(),
+                new CompressedXContent("{\"baz\":\"eggplant\"}"),
+                Collections.singletonMap("alias", AliasMetaData.builder("alias").build()))));
     }
 
     private static final String MAPPING_SOURCE1 = "{\"mapping1\":{\"text1\":{\"type\":\"string\"}}}";