Merge branch 'refactor-clusters' into 'master'

Refactor Clusters to be consisted from GcpProvider and KubernetesPlatform

See merge request gitlab-org/gitlab-ce!14879

26 files changed, 539 insertions, 327 deletions

diff --git a/app/controllers/projects/clusters_controller.rb b/app/controllers/projects/clusters_controller.rb
index 03019b0becc..c1692ea2569 100644
--- a/app/controllers/projects/clusters_controller.rb
+++ b/app/controllers/projects/clusters_controller.rb
@@ -27,11 +27,13 @@ class Projects::ClustersController < Projects::ApplicationController
   end
 
   def new
-    @cluster = project.build_cluster
+    @cluster = Clusters::Cluster.new.tap do |cluster|
+      cluster.build_provider_gcp
+    end
   end
 
   def create
-    @cluster = Ci::CreateClusterService
+    @cluster = Clusters::CreateService
       .new(project, current_user, create_params)
       .execute(token_in_session)
 
@@ -58,7 +60,7 @@ class Projects::ClustersController < Projects::ApplicationController
   end
 
   def update
-    Ci::UpdateClusterService
+    Clusters::UpdateService
       .new(project, current_user, update_params)
       .execute(cluster)
 
@@ -88,19 +90,19 @@ class Projects::ClustersController < Projects::ApplicationController
 
   def create_params
     params.require(:cluster).permit(
-      :gcp_project_id,
-      :gcp_cluster_zone,
-      :gcp_cluster_name,
-      :gcp_cluster_size,
-      :gcp_machine_type,
-      :project_namespace,
-      :enabled)
+      :enabled,
+      :name,
+      :provider_type,
+      provider_gcp_attributes: [
+        :gcp_project_id,
+        :zone,
+        :num_nodes,
+        :machine_type
+      ])
   end
 
   def update_params
-    params.require(:cluster).permit(
-      :project_namespace,
-      :enabled)
+    params.require(:cluster).permit(:enabled)
   end
 
   def authorize_google_api
diff --git a/app/models/clusters/cluster.rb b/app/models/clusters/cluster.rb
new file mode 100644
index 00000000000..955dba51745
--- /dev/null
+++ b/app/models/clusters/cluster.rb
@@ -0,0 +1,73 @@
+module Clusters
+  class Cluster < ActiveRecord::Base
+    include Presentable
+
+    self.table_name = 'clusters'
+
+    belongs_to :user
+
+    has_many :cluster_projects, class_name: 'Clusters::Project'
+    has_many :projects, through: :cluster_projects, class_name: '::Project'
+
+    # we force autosave to happen when we save `Cluster` model
+    has_one :provider_gcp, class_name: 'Clusters::Providers::Gcp', autosave: true
+
+    # We have to ":destroy" it today to ensure that we clean also the Kubernetes Integration
+    has_one :platform_kubernetes, class_name: 'Clusters::Platforms::Kubernetes', autosave: true, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
+
+    accepts_nested_attributes_for :provider_gcp, update_only: true
+    accepts_nested_attributes_for :platform_kubernetes, update_only: true
+
+    validates :name, cluster_name: true
+    validate :restrict_modification, on: :update
+
+    # TODO: Move back this into Clusters::Platforms::Kubernetes in 10.3
+    # We need callback here because `enabled` belongs to Clusters::Cluster
+    # Callbacks in Clusters::Platforms::Kubernetes will not be called after update
+    after_save :update_kubernetes_integration!
+
+    delegate :status, to: :provider, allow_nil: true
+    delegate :status_reason, to: :provider, allow_nil: true
+    delegate :status_name, to: :provider, allow_nil: true
+    delegate :on_creation?, to: :provider, allow_nil: true
+    delegate :update_kubernetes_integration!, to: :platform, allow_nil: true
+
+    enum platform_type: {
+      kubernetes: 1
+    }
+
+    enum provider_type: {
+      user: 0,
+      gcp: 1
+    }
+
+    scope :enabled, -> { where(enabled: true) }
+    scope :disabled, -> { where(enabled: false) }
+
+    def provider
+      return provider_gcp if gcp?
+    end
+
+    def platform
+      return platform_kubernetes if kubernetes?
+    end
+
+    def first_project
+      return @first_project if defined?(@first_project)
+
+      @first_project = projects.first
+    end
+    alias_method :project, :first_project
+
+    private
+
+    def restrict_modification
+      if provider&.on_creation?
+        errors.add(:base, "cannot modify during creation")
+        return false
+      end
+
+      true
+    end
+  end
+end
diff --git a/app/models/clusters/platforms/kubernetes.rb b/app/models/clusters/platforms/kubernetes.rb
new file mode 100644
index 00000000000..b11701797c2
--- /dev/null
+++ b/app/models/clusters/platforms/kubernetes.rb
@@ -0,0 +1,101 @@
+module Clusters
+  module Platforms
+    class Kubernetes < ActiveRecord::Base
+      self.table_name = 'cluster_platforms_kubernetes'
+
+      belongs_to :cluster, inverse_of: :platform_kubernetes, class_name: 'Clusters::Cluster'
+
+      attr_encrypted :password,
+        mode: :per_attribute_iv,
+        key: Gitlab::Application.secrets.db_key_base,
+        algorithm: 'aes-256-cbc'
+
+      attr_encrypted :token,
+        mode: :per_attribute_iv,
+        key: Gitlab::Application.secrets.db_key_base,
+        algorithm: 'aes-256-cbc'
+
+      before_validation :enforce_namespace_to_lower_case
+
+      validates :namespace,
+        allow_blank: true,
+        length: 1..63,
+        format: {
+          with: Gitlab::Regex.kubernetes_namespace_regex,
+          message: Gitlab::Regex.kubernetes_namespace_regex_message
+        }
+
+      # We expect to be `active?` only when enabled and cluster is created (the api_url is assigned)
+      validates :api_url, url: true, presence: true
+      validates :token, presence: true
+
+      # TODO: Glue code till we migrate Kubernetes Integration into Platforms::Kubernetes
+      after_destroy :destroy_kubernetes_integration!
+
+      alias_attribute :ca_pem, :ca_cert
+
+      delegate :project, to: :cluster, allow_nil: true
+      delegate :enabled?, to: :cluster, allow_nil: true
+
+      class << self
+        def namespace_for_project(project)
+          "#{project.path}-#{project.id}"
+        end
+      end
+
+      def actual_namespace
+        if namespace.present?
+          namespace
+        else
+          default_namespace
+        end
+      end
+
+      def default_namespace
+        self.class.namespace_for_project(project) if project
+      end
+
+      def update_kubernetes_integration!
+        raise 'Kubernetes service already configured' unless manages_kubernetes_service?
+
+        # This is neccesary, otheriwse enabled? returns true even though cluster updated with enabled: false
+        cluster.reload
+
+        ensure_kubernetes_service&.update!(
+          active: enabled?,
+          api_url: api_url,
+          namespace: namespace,
+          token: token,
+          ca_pem: ca_cert
+        )
+      end
+
+      private
+
+      def enforce_namespace_to_lower_case
+        self.namespace = self.namespace&.downcase
+      end
+
+      # TODO: glue code till we migrate Kubernetes Service into Platforms::Kubernetes class
+      def manages_kubernetes_service?
+        return true unless kubernetes_service&.active?
+
+        kubernetes_service.api_url == api_url
+      end
+
+      def destroy_kubernetes_integration!
+        return unless manages_kubernetes_service?
+
+        kubernetes_service&.destroy!
+      end
+
+      def kubernetes_service
+        @kubernetes_service ||= project&.kubernetes_service
+      end
+
+      def ensure_kubernetes_service
+        @kubernetes_service ||= kubernetes_service || project&.build_kubernetes_service
+      end
+    end
+  end
+end
diff --git a/app/models/clusters/project.rb b/app/models/clusters/project.rb
new file mode 100644
index 00000000000..eeb734b20b8
--- /dev/null
+++ b/app/models/clusters/project.rb
@@ -0,0 +1,8 @@
+module Clusters
+  class Project < ActiveRecord::Base
+    self.table_name = 'cluster_projects'
+
+    belongs_to :cluster, class_name: 'Clusters::Cluster'
+    belongs_to :project, class_name: '::Project'
+  end
+end
diff --git a/app/models/clusters/providers/gcp.rb b/app/models/clusters/providers/gcp.rb
new file mode 100644
index 00000000000..c4391729dd7
--- /dev/null
+++ b/app/models/clusters/providers/gcp.rb
@@ -0,0 +1,79 @@
+module Clusters
+  module Providers
+    class Gcp < ActiveRecord::Base
+      self.table_name = 'cluster_providers_gcp'
+
+      belongs_to :cluster, inverse_of: :provider_gcp, class_name: 'Clusters::Cluster'
+
+      default_value_for :zone, 'us-central1-a'
+      default_value_for :num_nodes, 3
+      default_value_for :machine_type, 'n1-standard-4'
+
+      attr_encrypted :access_token,
+        mode: :per_attribute_iv,
+        key: Gitlab::Application.secrets.db_key_base,
+        algorithm: 'aes-256-cbc'
+
+      validates :gcp_project_id,
+        length: 1..63,
+        format: {
+          with: Gitlab::Regex.kubernetes_namespace_regex,
+          message: Gitlab::Regex.kubernetes_namespace_regex_message
+        }
+
+      validates :zone, presence: true
+
+      validates :num_nodes,
+        presence: true,
+        numericality: {
+          only_integer: true,
+          greater_than: 0
+        }
+
+      state_machine :status, initial: :scheduled do
+        state :scheduled, value: 1
+        state :creating, value: 2
+        state :created, value: 3
+        state :errored, value: 4
+
+        event :make_creating do
+          transition any - [:creating] => :creating
+        end
+
+        event :make_created do
+          transition any - [:created] => :created
+        end
+
+        event :make_errored do
+          transition any - [:errored] => :errored
+        end
+
+        before_transition any => [:errored, :created] do |provider|
+          provider.access_token = nil
+          provider.operation_id = nil
+        end
+
+        before_transition any => [:creating] do |provider, transition|
+          operation_id = transition.args.first
+          raise ArgumentError.new('operation_id is required') unless operation_id.present?
+          provider.operation_id = operation_id
+        end
+
+        before_transition any => [:errored] do |provider, transition|
+          status_reason = transition.args.first
+          provider.status_reason = status_reason if status_reason
+        end
+      end
+
+      def on_creation?
+        scheduled? || creating?
+      end
+
+      def api_client
+        return unless access_token
+
+        @api_client ||= GoogleApi::CloudPlatform::Client.new(access_token, nil)
+      end
+    end
+  end
+end
diff --git a/app/models/gcp/cluster.rb b/app/models/gcp/cluster.rb
deleted file mode 100644
index 162a690c0e3..00000000000
--- a/app/models/gcp/cluster.rb
+++ /dev/null
@@ -1,116 +0,0 @@
-module Gcp
-  class Cluster < ActiveRecord::Base
-    extend Gitlab::Gcp::Model
-    include Presentable
-
-    belongs_to :project, inverse_of: :cluster
-    belongs_to :user
-    belongs_to :service
-
-    scope :enabled, -> { where(enabled: true) }
-    scope :disabled, -> { where(enabled: false) }
-
-    default_value_for :gcp_cluster_zone, 'us-central1-a'
-    default_value_for :gcp_cluster_size, 3
-    default_value_for :gcp_machine_type, 'n1-standard-4'
-
-    attr_encrypted :password,
-      mode: :per_attribute_iv,
-      key: Gitlab::Application.secrets.db_key_base,
-      algorithm: 'aes-256-cbc'
-
-    attr_encrypted :kubernetes_token,
-      mode: :per_attribute_iv,
-      key: Gitlab::Application.secrets.db_key_base,
-      algorithm: 'aes-256-cbc'
-
-    attr_encrypted :gcp_token,
-      mode: :per_attribute_iv,
-      key: Gitlab::Application.secrets.db_key_base,
-      algorithm: 'aes-256-cbc'
-
-    validates :gcp_project_id,
-      length: 1..63,
-      format: {
-        with: Gitlab::Regex.kubernetes_namespace_regex,
-        message: Gitlab::Regex.kubernetes_namespace_regex_message
-      }
-
-    validates :gcp_cluster_name,
-      length: 1..63,
-      format: {
-        with: Gitlab::Regex.kubernetes_namespace_regex,
-        message: Gitlab::Regex.kubernetes_namespace_regex_message
-      }
-
-    validates :gcp_cluster_zone, presence: true
-
-    validates :gcp_cluster_size,
-      presence: true,
-      numericality: {
-        only_integer: true,
-        greater_than: 0
-      }
-
-    validates :project_namespace,
-      allow_blank: true,
-      length: 1..63,
-      format: {
-        with: Gitlab::Regex.kubernetes_namespace_regex,
-        message: Gitlab::Regex.kubernetes_namespace_regex_message
-      }
-
-    # if we do not do status transition we prevent change
-    validate :restrict_modification, on: :update, unless: :status_changed?
-
-    state_machine :status, initial: :scheduled do
-      state :scheduled, value: 1
-      state :creating, value: 2
-      state :created, value: 3
-      state :errored, value: 4
-
-      event :make_creating do
-        transition any - [:creating] => :creating
-      end
-
-      event :make_created do
-        transition any - [:created] => :created
-      end
-
-      event :make_errored do
-        transition any - [:errored] => :errored
-      end
-
-      before_transition any => [:errored, :created] do |cluster|
-        cluster.gcp_token = nil
-        cluster.gcp_operation_id = nil
-      end
-
-      before_transition any => [:errored] do |cluster, transition|
-        status_reason = transition.args.first
-        cluster.status_reason = status_reason if status_reason
-      end
-    end
-
-    def project_namespace_placeholder
-      "#{project.path}-#{project.id}"
-    end
-
-    def on_creation?
-      scheduled? || creating?
-    end
-
-    def api_url
-      'https://' + endpoint if endpoint
-    end
-
-    def restrict_modification
-      if on_creation?
-        errors.add(:base, "cannot modify during creation")
-        return false
-      end
-
-      true
-    end
-  end
-end
diff --git a/app/models/project.rb b/app/models/project.rb
index 3a300a4a03c..d8607d04a98 100644
--- a/app/models/project.rb
+++ b/app/models/project.rb
@@ -186,7 +186,9 @@ class Project < ActiveRecord::Base
   has_one :import_data, class_name: 'ProjectImportData', inverse_of: :project, autosave: true
   has_one :project_feature, inverse_of: :project
   has_one :statistics, class_name: 'ProjectStatistics'
-  has_one :cluster, class_name: 'Gcp::Cluster', inverse_of: :project
+
+  has_one :cluster_project, class_name: 'Clusters::Project'
+  has_one :cluster, through: :cluster_project, class_name: 'Clusters::Cluster'
 
   # Container repositories need to remove data from the container registry,
   # which is not managed by the DB. Hence we're still using dependent: :destroy
diff --git a/app/policies/gcp/cluster_policy.rb b/app/policies/clusters/cluster_policy.rb
index e77173ea6e1..1f7c13072b9 100644
--- a/app/policies/gcp/cluster_policy.rb
+++ b/app/policies/clusters/cluster_policy.rb
@@ -1,8 +1,8 @@
-module Gcp
+module Clusters
   class ClusterPolicy < BasePolicy
     alias_method :cluster, :subject
 
-    delegate { @subject.project }
+    delegate { cluster.project }
 
     rule { can?(:master_access) }.policy do
       enable :update_cluster
diff --git a/app/presenters/gcp/cluster_presenter.rb b/app/presenters/clusters/cluster_presenter.rb
index f7908f92a37..01cb59d0d44 100644
--- a/app/presenters/gcp/cluster_presenter.rb
+++ b/app/presenters/clusters/cluster_presenter.rb
@@ -1,9 +1,9 @@
-module Gcp
+module Clusters
   class ClusterPresenter < Gitlab::View::Presenter::Delegated
     presents :cluster
 
     def gke_cluster_url
-      "https://console.cloud.google.com/kubernetes/clusters/details/#{gcp_cluster_zone}/#{gcp_cluster_name}"
+      "https://console.cloud.google.com/kubernetes/clusters/details/#{provider.zone}/#{name}" if gcp?
     end
   end
 end
diff --git a/app/services/ci/create_cluster_service.rb b/app/services/ci/create_cluster_service.rb
deleted file mode 100644
index f7ee0e468e2..00000000000
--- a/app/services/ci/create_cluster_service.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-module Ci
-  class CreateClusterService < BaseService
-    def execute(access_token)
-      params['gcp_machine_type'] ||= GoogleApi::CloudPlatform::Client::DEFAULT_MACHINE_TYPE
-
-      cluster_params =
-        params.merge(user: current_user,
-                     gcp_token: access_token)
-
-      project.create_cluster(cluster_params).tap do |cluster|
-        ClusterProvisionWorker.perform_async(cluster.id) if cluster.persisted?
-      end
-    end
-  end
-end
diff --git a/app/services/ci/fetch_gcp_operation_service.rb b/app/services/ci/fetch_gcp_operation_service.rb
deleted file mode 100644
index 0b68e4d6ea9..00000000000
--- a/app/services/ci/fetch_gcp_operation_service.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-module Ci
-  class FetchGcpOperationService
-    def execute(cluster)
-      api_client =
-        GoogleApi::CloudPlatform::Client.new(cluster.gcp_token, nil)
-
-      operation = api_client.projects_zones_operations(
-        cluster.gcp_project_id,
-        cluster.gcp_cluster_zone,
-        cluster.gcp_operation_id)
-
-      yield(operation) if block_given?
-    rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
-      return cluster.make_errored!("Failed to request to CloudPlatform; #{e.message}")
-    end
-  end
-end
diff --git a/app/services/ci/finalize_cluster_creation_service.rb b/app/services/ci/finalize_cluster_creation_service.rb
deleted file mode 100644
index 347875c5697..00000000000
--- a/app/services/ci/finalize_cluster_creation_service.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-module Ci
-  class FinalizeClusterCreationService
-    def execute(cluster)
-      api_client =
-        GoogleApi::CloudPlatform::Client.new(cluster.gcp_token, nil)
-
-      begin
-        gke_cluster = api_client.projects_zones_clusters_get(
-          cluster.gcp_project_id,
-          cluster.gcp_cluster_zone,
-          cluster.gcp_cluster_name)
-      rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
-        return cluster.make_errored!("Failed to request to CloudPlatform; #{e.message}")
-      end
-
-      endpoint = gke_cluster.endpoint
-      api_url = 'https://' + endpoint
-      ca_cert = Base64.decode64(gke_cluster.master_auth.cluster_ca_certificate)
-      username = gke_cluster.master_auth.username
-      password = gke_cluster.master_auth.password
-
-      kubernetes_token = Ci::FetchKubernetesTokenService.new(
-        api_url, ca_cert, username, password).execute
-
-      unless kubernetes_token
-        return cluster.make_errored!('Failed to get a default token of kubernetes')
-      end
-
-      Ci::IntegrateClusterService.new.execute(
-        cluster, endpoint, ca_cert, kubernetes_token, username, password)
-    end
-  end
-end
diff --git a/app/services/ci/integrate_cluster_service.rb b/app/services/ci/integrate_cluster_service.rb
deleted file mode 100644
index d123ce8d26b..00000000000
--- a/app/services/ci/integrate_cluster_service.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-module Ci
-  class IntegrateClusterService
-    def execute(cluster, endpoint, ca_cert, token, username, password)
-      Gcp::Cluster.transaction do
-        cluster.update!(
-          enabled: true,
-          endpoint: endpoint,
-          ca_cert: ca_cert,
-          kubernetes_token: token,
-          username: username,
-          password: password,
-          service: cluster.project.find_or_initialize_service('kubernetes'),
-          status_event: :make_created)
-
-        cluster.service.update!(
-          active: true,
-          api_url: cluster.api_url,
-          ca_pem: ca_cert,
-          namespace: cluster.project_namespace,
-          token: token)
-      end
-    rescue ActiveRecord::RecordInvalid => e
-      cluster.make_errored!("Failed to integrate cluster into kubernetes_service: #{e.message}")
-    end
-  end
-end
diff --git a/app/services/ci/provision_cluster_service.rb b/app/services/ci/provision_cluster_service.rb
deleted file mode 100644
index 52d80b01813..00000000000
--- a/app/services/ci/provision_cluster_service.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-module Ci
-  class ProvisionClusterService
-    def execute(cluster)
-      api_client =
-        GoogleApi::CloudPlatform::Client.new(cluster.gcp_token, nil)
-
-      begin
-        operation = api_client.projects_zones_clusters_create(
-          cluster.gcp_project_id,
-          cluster.gcp_cluster_zone,
-          cluster.gcp_cluster_name,
-          cluster.gcp_cluster_size,
-          machine_type: cluster.gcp_machine_type)
-      rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
-        return cluster.make_errored!("Failed to request to CloudPlatform; #{e.message}")
-      end
-
-      unless operation.status == 'RUNNING' || operation.status == 'PENDING'
-        return cluster.make_errored!("Operation status is unexpected; #{operation.status_message}")
-      end
-
-      cluster.gcp_operation_id = api_client.parse_operation_id(operation.self_link)
-
-      unless cluster.gcp_operation_id
-        return cluster.make_errored!('Can not find operation_id from self_link')
-      end
-
-      if cluster.make_creating
-        WaitForClusterCreationWorker.perform_in(
-          WaitForClusterCreationWorker::INITIAL_INTERVAL, cluster.id)
-      else
-        return cluster.make_errored!("Failed to update cluster record; #{cluster.errors}")
-      end
-    end
-  end
-end
diff --git a/app/services/ci/update_cluster_service.rb b/app/services/ci/update_cluster_service.rb
deleted file mode 100644
index 70d88fca660..00000000000
--- a/app/services/ci/update_cluster_service.rb
+++ /dev/null
@@ -1,22 +0,0 @@
-module Ci
-  class UpdateClusterService < BaseService
-    def execute(cluster)
-      Gcp::Cluster.transaction do
-        cluster.update!(params)
-
-        if params['enabled'] == 'true'
-          cluster.service.update!(
-            active: true,
-            api_url: cluster.api_url,
-            ca_pem: cluster.ca_cert,
-            namespace: cluster.project_namespace,
-            token: cluster.kubernetes_token)
-        else
-          cluster.service.update!(active: false)
-        end
-      end
-    rescue ActiveRecord::RecordInvalid => e
-      cluster.errors.add(:base, e.message)
-    end
-  end
-end
diff --git a/app/services/clusters/create_service.rb b/app/services/clusters/create_service.rb
new file mode 100644
index 00000000000..1d407739b21
--- /dev/null
+++ b/app/services/clusters/create_service.rb
@@ -0,0 +1,29 @@
+module Clusters
+  class CreateService < BaseService
+    attr_reader :access_token
+
+    def execute(access_token)
+      @access_token = access_token
+
+      create_cluster.tap do |cluster|
+        ClusterProvisionWorker.perform_async(cluster.id) if cluster.persisted?
+      end
+    end
+
+    private
+
+    def create_cluster
+      Clusters::Cluster.create(cluster_params)
+    end
+
+    def cluster_params
+      return @cluster_params if defined?(@cluster_params)
+
+      params[:provider_gcp_attributes].try do |provider|
+        provider[:access_token] = access_token
+      end
+
+      @cluster_params = params.merge(user: current_user, projects: [project])
+    end
+  end
+end
diff --git a/app/services/clusters/gcp/fetch_operation_service.rb b/app/services/clusters/gcp/fetch_operation_service.rb
new file mode 100644
index 00000000000..a4cd3ca5c11
--- /dev/null
+++ b/app/services/clusters/gcp/fetch_operation_service.rb
@@ -0,0 +1,16 @@
+module Clusters
+  module Gcp
+    class FetchOperationService
+      def execute(provider)
+        operation = provider.api_client.projects_zones_operations(
+          provider.gcp_project_id,
+          provider.zone,
+          provider.operation_id)
+
+        yield(operation) if block_given?
+      rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
+        provider.make_errored!("Failed to request to CloudPlatform; #{e.message}")
+      end
+    end
+  end
+end
diff --git a/app/services/clusters/gcp/finalize_creation_service.rb b/app/services/clusters/gcp/finalize_creation_service.rb
new file mode 100644
index 00000000000..cea56f4e849
--- /dev/null
+++ b/app/services/clusters/gcp/finalize_creation_service.rb
@@ -0,0 +1,56 @@
+module Clusters
+  module Gcp
+    class FinalizeCreationService
+      attr_reader :provider
+
+      def execute(provider)
+        @provider = provider
+
+        configure_provider
+        configure_kubernetes
+
+        cluster.save!
+      rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
+        provider.make_errored!("Failed to request to CloudPlatform; #{e.message}")
+      rescue ActiveRecord::RecordInvalid => e
+        provider.make_errored!("Failed to configure GKE Cluster: #{e.message}")
+      end
+
+      private
+
+      def configure_provider
+        provider.endpoint = gke_cluster.endpoint
+        provider.status_event = :make_created
+      end
+
+      def configure_kubernetes
+        cluster.platform_type = :kubernetes
+        cluster.build_platform_kubernetes(
+          api_url: 'https://' + gke_cluster.endpoint,
+          ca_cert: Base64.decode64(gke_cluster.master_auth.cluster_ca_certificate),
+          username: gke_cluster.master_auth.username,
+          password: gke_cluster.master_auth.password,
+          token: request_kuberenetes_token)
+      end
+
+      def request_kuberenetes_token
+        Ci::FetchKubernetesTokenService.new(
+          'https://' + gke_cluster.endpoint,
+          Base64.decode64(gke_cluster.master_auth.cluster_ca_certificate),
+          gke_cluster.master_auth.username,
+          gke_cluster.master_auth.password).execute
+      end
+
+      def gke_cluster
+        @gke_cluster ||= provider.api_client.projects_zones_clusters_get(
+          provider.gcp_project_id,
+          provider.zone,
+          cluster.name)
+      end
+
+      def cluster
+        @cluster ||= provider.cluster
+      end
+    end
+  end
+end
diff --git a/app/services/clusters/gcp/provision_service.rb b/app/services/clusters/gcp/provision_service.rb
new file mode 100644
index 00000000000..8beea5a8cfb
--- /dev/null
+++ b/app/services/clusters/gcp/provision_service.rb
@@ -0,0 +1,47 @@
+module Clusters
+  module Gcp
+    class ProvisionService
+      attr_reader :provider
+
+      def execute(provider)
+        @provider = provider
+
+        get_operation_id do |operation_id|
+          if provider.make_creating(operation_id)
+            WaitForClusterCreationWorker.perform_in(
+              Clusters::Gcp::VerifyProvisionStatusService::INITIAL_INTERVAL,
+              provider.cluster_id)
+          else
+            provider.make_errored!("Failed to update provider record; #{provider.errors}")
+          end
+        end
+      end
+
+      private
+
+      def get_operation_id
+        operation = provider.api_client.projects_zones_clusters_create(
+          provider.gcp_project_id,
+          provider.zone,
+          provider.cluster.name,
+          provider.num_nodes,
+          machine_type: provider.machine_type)
+
+        unless operation.status == 'PENDING' || operation.status == 'RUNNING'
+          return provider.make_errored!("Operation status is unexpected; #{operation.status_message}")
+        end
+
+        operation_id = provider.api_client.parse_operation_id(operation.self_link)
+
+        unless operation_id
+          return provider.make_errored!('Can not find operation_id from self_link')
+        end
+
+        yield(operation_id)
+
+      rescue Google::Apis::ServerError, Google::Apis::ClientError, Google::Apis::AuthorizationError => e
+        provider.make_errored!("Failed to request to CloudPlatform; #{e.message}")
+      end
+    end
+  end
+end
diff --git a/app/services/clusters/gcp/verify_provision_status_service.rb b/app/services/clusters/gcp/verify_provision_status_service.rb
new file mode 100644
index 00000000000..bc33756f27c
--- /dev/null
+++ b/app/services/clusters/gcp/verify_provision_status_service.rb
@@ -0,0 +1,48 @@
+module Clusters
+  module Gcp
+    class VerifyProvisionStatusService
+      attr_reader :provider
+
+      INITIAL_INTERVAL = 2.minutes
+      EAGER_INTERVAL = 10.seconds
+      TIMEOUT = 20.minutes
+
+      def execute(provider)
+        @provider = provider
+
+        request_operation do |operation|
+          case operation.status
+          when 'PENDING', 'RUNNING'
+            continue_creation(operation)
+          when 'DONE'
+            finalize_creation
+          else
+            return provider.make_errored!("Unexpected operation status; #{operation.status} #{operation.status_message}")
+          end
+        end
+      end
+
+      private
+
+      def continue_creation(operation)
+        if elapsed_time_from_creation(operation) < TIMEOUT
+          WaitForClusterCreationWorker.perform_in(EAGER_INTERVAL, provider.cluster_id)
+        else
+          provider.make_errored!("Cluster creation time exceeds timeout; #{TIMEOUT}")
+        end
+      end
+
+      def elapsed_time_from_creation(operation)
+        Time.now.utc - operation.start_time.to_time.utc
+      end
+
+      def finalize_creation
+        Clusters::Gcp::FinalizeCreationService.new.execute(provider)
+      end
+
+      def request_operation(&blk)
+        Clusters::Gcp::FetchOperationService.new.execute(provider, &blk)
+      end
+    end
+  end
+end
diff --git a/app/services/clusters/update_service.rb b/app/services/clusters/update_service.rb
new file mode 100644
index 00000000000..989218e32a2
--- /dev/null
+++ b/app/services/clusters/update_service.rb
@@ -0,0 +1,7 @@
+module Clusters
+  class UpdateService < BaseService
+    def execute(cluster)
+      cluster.update(params)
+    end
+  end
+end
diff --git a/app/validators/cluster_name_validator.rb b/app/validators/cluster_name_validator.rb
new file mode 100644
index 00000000000..13ec342f399
--- /dev/null
+++ b/app/validators/cluster_name_validator.rb
@@ -0,0 +1,24 @@
+# ClusterNameValidator
+#
+# Custom validator for ClusterName.
+class ClusterNameValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if record.user?
+      unless value.present?
+        record.errors.add(attribute, " has to be present")
+      end
+    elsif record.gcp?
+      if record.persisted? && record.name_changed?
+        record.errors.add(attribute, " can not be changed because it's synchronized with provider")
+      end
+
+      unless value.length >= 1 && value.length <= 63
+        record.errors.add(attribute, " is invalid syntax")
+      end
+
+      unless value =~ Gitlab::Regex.kubernetes_namespace_regex
+        record.errors.add(attribute, Gitlab::Regex.kubernetes_namespace_regex_message)
+      end
+    end
+  end
+end
diff --git a/app/views/projects/clusters/_form.html.haml b/app/views/projects/clusters/_form.html.haml
index 371cdb1e403..d8e5b55bb88 100644
--- a/app/views/projects/clusters/_form.html.haml
+++ b/app/views/projects/clusters/_form.html.haml
@@ -4,34 +4,32 @@
       - link_to_help_page = link_to(s_('ClusterIntegration|help page'), help_page_path('user/project/clusters/index'), target: '_blank', rel: 'noopener noreferrer')
       = s_('ClusterIntegration|Read our %{link_to_help_page} on cluster integration.').html_safe % { link_to_help_page: link_to_help_page}
 
-      = form_for [@project.namespace.becomes(Namespace), @project, @cluster] do |field|
+      = form_for @cluster, url: namespace_project_clusters_path(@project.namespace, @project, @cluster), as: :cluster do |field|
+        = field.hidden_field :provider_type, value: :gcp
         = form_errors(@cluster)
         .form-group
-          = field.label :gcp_cluster_name, s_('ClusterIntegration|Cluster name')
-          = field.text_field :gcp_cluster_name, class: 'form-control'
+          = field.label :name, s_('ClusterIntegration|Cluster name')
+          = field.text_field :name, class: 'form-control'
 
-        .form-group
-          = field.label :gcp_project_id, s_('ClusterIntegration|Google Cloud Platform project ID')
-          = link_to(s_('ClusterIntegration|See your projects'), 'https://console.cloud.google.com/home/dashboard', target: '_blank', rel: 'noopener noreferrer')
-          = field.text_field :gcp_project_id, class: 'form-control'
-
-        .form-group
-          = field.label :gcp_cluster_zone, s_('ClusterIntegration|Zone')
-          = link_to(s_('ClusterIntegration|See zones'), 'https://cloud.google.com/compute/docs/regions-zones/regions-zones', target: '_blank', rel: 'noopener noreferrer')
-          = field.text_field :gcp_cluster_zone, class: 'form-control', placeholder: 'us-central1-a'
+        = field.fields_for :provider_gcp, @cluster.provider_gcp do |provider_gcp_field|
+          .form-group
+            = provider_gcp_field.label :gcp_project_id, s_('ClusterIntegration|Google Cloud Platform project ID')
+            = link_to(s_('ClusterIntegration|See your projects'), 'https://console.cloud.google.com/home/dashboard', target: '_blank', rel: 'noopener noreferrer')
+            = provider_gcp_field.text_field :gcp_project_id, class: 'form-control'
 
-        .form-group
-          = field.label :gcp_cluster_size, s_('ClusterIntegration|Number of nodes')
-          = field.text_field :gcp_cluster_size, class: 'form-control', placeholder: '3'
+          .form-group
+            = provider_gcp_field.label :zone, s_('ClusterIntegration|Zone')
+            = link_to(s_('ClusterIntegration|See zones'), 'https://cloud.google.com/compute/docs/regions-zones/regions-zones', target: '_blank', rel: 'noopener noreferrer')
+            = provider_gcp_field.text_field :zone, class: 'form-control', placeholder: 'us-central1-a'
 
-        .form-group
-          = field.label :gcp_machine_type, s_('ClusterIntegration|Machine type')
-          = link_to(s_('ClusterIntegration|See machine types'), 'https://cloud.google.com/compute/docs/machine-types', target: '_blank', rel: 'noopener noreferrer')
-          = field.text_field :gcp_machine_type, class: 'form-control', placeholder: 'n1-standard-4'
+          .form-group
+            = provider_gcp_field.label :num_nodes, s_('ClusterIntegration|Number of nodes')
+            = provider_gcp_field.text_field :num_nodes, class: 'form-control', placeholder: '3'
 
           .form-group
-          = field.label :project_namespace, s_('ClusterIntegration|Project namespace (optional, unique)')
-          = field.text_field :project_namespace, class: 'form-control', placeholder: @cluster.project_namespace_placeholder
+            = provider_gcp_field.label :machine_type, s_('ClusterIntegration|Machine type')
+            = link_to(s_('ClusterIntegration|See machine types'), 'https://cloud.google.com/compute/docs/machine-types', target: '_blank', rel: 'noopener noreferrer')
+            = provider_gcp_field.text_field :machine_type, class: 'form-control', placeholder: 'n1-standard-4'
 
         .form-group
           = field.submit s_('ClusterIntegration|Create cluster'), class: 'btn btn-save'
diff --git a/app/views/projects/clusters/show.html.haml b/app/views/projects/clusters/show.html.haml
index dbe6f8beb95..ebb9383ca12 100644
--- a/app/views/projects/clusters/show.html.haml
+++ b/app/views/projects/clusters/show.html.haml
@@ -33,7 +33,7 @@
         - else
           = s_('ClusterIntegration|Cluster integration is disabled for this project.')
 
-    = form_for [@project.namespace.becomes(Namespace), @project, @cluster] do |field|
+    = form_for @cluster, url: namespace_project_cluster_path(@project.namespace, @project, @cluster), as: :cluster do |field|
       = form_errors(@cluster)
       .form-group.append-bottom-20
         %label.append-bottom-10
@@ -62,9 +62,9 @@
         %label.append-bottom-10{ for: 'cluter-name' }
           = s_('ClusterIntegration|Cluster name')
         .input-group
-          %input.form-control.cluster-name{ value: @cluster.gcp_cluster_name, disabled: true }
+          %input.form-control.cluster-name{ value: @cluster.name, disabled: true }
           %span.input-group-addon.clipboard-addon
-            = clipboard_button(text: @cluster.gcp_cluster_name, title: s_('ClusterIntegration|Copy cluster name'))
+            = clipboard_button(text: @cluster.name, title: s_('ClusterIntegration|Copy cluster name'))
 
   %section.settings.no-animate#js-cluster-advanced-settings{ class: ('expanded' if expanded) }
     .settings-header
diff --git a/app/workers/cluster_provision_worker.rb b/app/workers/cluster_provision_worker.rb
index 63300b58a25..b01f9708424 100644
--- a/app/workers/cluster_provision_worker.rb
+++ b/app/workers/cluster_provision_worker.rb
@@ -3,8 +3,10 @@ class ClusterProvisionWorker
   include ClusterQueue
 
   def perform(cluster_id)
-    Gcp::Cluster.find_by_id(cluster_id).try do |cluster|
-      Ci::ProvisionClusterService.new.execute(cluster)
+    Clusters::Cluster.find_by_id(cluster_id).try do |cluster|
+      cluster.provider.try do |provider|
+        Clusters::Gcp::ProvisionService.new.execute(provider) if cluster.gcp?
+      end
     end
   end
 end
diff --git a/app/workers/wait_for_cluster_creation_worker.rb b/app/workers/wait_for_cluster_creation_worker.rb
index 5aa3bbdaa9d..241ed3901dc 100644
--- a/app/workers/wait_for_cluster_creation_worker.rb
+++ b/app/workers/wait_for_cluster_creation_worker.rb
@@ -2,25 +2,10 @@ class WaitForClusterCreationWorker
   include Sidekiq::Worker
   include ClusterQueue
 
-  INITIAL_INTERVAL = 2.minutes
-  EAGER_INTERVAL = 10.seconds
-  TIMEOUT = 20.minutes
-
   def perform(cluster_id)
-    Gcp::Cluster.find_by_id(cluster_id).try do |cluster|
-      Ci::FetchGcpOperationService.new.execute(cluster) do |operation|
-        case operation.status
-        when 'RUNNING'
-          if TIMEOUT < Time.now.utc - operation.start_time.to_time.utc
-            return cluster.make_errored!("Cluster creation time exceeds timeout; #{TIMEOUT}")
-          end
-
-          WaitForClusterCreationWorker.perform_in(EAGER_INTERVAL, cluster.id)
-        when 'DONE'
-          Ci::FinalizeClusterCreationService.new.execute(cluster)
-        else
-          return cluster.make_errored!("Unexpected operation status; #{operation.status} #{operation.status_message}")
-        end
+    Clusters::Cluster.find_by_id(cluster_id).try do |cluster|
+      cluster.provider.try do |provider|
+        Clusters::Gcp::VerifyProvisionStatusService.new.execute(provider) if cluster.gcp?
       end
     end
   end