kubernetes_helper 0.2.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ca97bfb3e3dcb157198cf9f76092c740ecb3674bb76cdf7c91f6da7755d11fe
-  data.tar.gz: 581dfe0dbf80c2a7d0115430d6045edfca0d532f10d89ca5db7bcbc70beac706
+  metadata.gz: c24816e7925c930deb198ab8b10b9f820ad4f5f23b4b06ee5e65d8d1d0e82208
+  data.tar.gz: '06395250bc71d298cfcd7d56409fe98e1a4ecd614ee79e24d7dc9cdbf01d1d1b'
 SHA512:
-  metadata.gz: 1642945b8ca5ea192812c686ef4afad9b285deae77ebbdd4734af1b3a877ad0db819c2e306f738303f84a361cbc3d697f02cf711e5ba35ce1a0e0f1148c12878
-  data.tar.gz: 0f23916d6007d02e858e2db22f563724bf422f59a47807eec956349c60f5141795c7e8c392d4d0c3c2c7ff67ca8f430033120f4dac72a372763c65c9f93f3d62
+  metadata.gz: 0a59e813c49a519036e6532537a9d194626395fdf0e5cee6c751f32cfb3e4c5fdff5454ae67dfe0ce500ec2f2c3317915aec8ed9c2f85b175a101e58b2d0d9ad
+  data.tar.gz: 915c6cebb2e9f5829274d564c449d5c57ae3aa06ef524002c41e48920379d4126e6da444a9a08dc69df4492ec541c825484d2d579ef39e4e01e325e9dc627417

data/README.md

@@ -22,16 +22,16 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## Development
-
-
 ## TODO
 - Documentation
-- Tests
-- Rake generate
+    - Include conditional blocks
+    - Include hardcoded env values
+    - Tasks
+    - Add docs to include partials using `include_template 'sample.yml.erb'`
 - Rake verify files
+- Add one_step_configuration.sh
+- Fix if/end_if for blocks
+- Ability to copy specific template
 
 ## Contributing
 

data/Rakefile

@@ -5,7 +5,7 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec
 
 path = File.expand_path(__dir__)
 Dir.glob("#{path}/lib/tasks/**/*.rake").each { |f| import f }

data/exe/kubernetes_helper

@@ -4,34 +4,30 @@ require 'kubernetes_helper'
 
 case ARGV[0]
 # Parse variables and run provided command.
-#   Sample: DEPLOY_ENV=beta rake kubernetes_helper:run_command "gcloud compute addresses create \#{ingress.ip_name} --global"'
+#   Sample: DEPLOY_ENV=beta rake kubernetes_helper:run_command
+#     "gcloud compute addresses create \#{ingress.ip_name} --global"'
 when 'run_command'
   KubernetesHelper::Core.new(ENV['DEPLOY_ENV']).run_command(ARGV[1])
-
 # Run the deployment script.
-#   Sample: DEPLOY_ENV=beta rake kubernetes_helper:run_deployment "cd_gcloud.sh"
+#   Sample: DEPLOY_ENV=beta kubernetes_helper run_deployment "cd_gcloud.sh"
 when 'run_deployment'
-  script_path = KubernetesHelper.settings_path(ARGV[1])
-  KubernetesHelper::Core.new(ENV['DEPLOY_ENV']).run_cd_script(script_path)
-
+  script_path = KubernetesHelper.settings_path(ARGV[1], use_template: true)
+  KubernetesHelper::Core.new(ENV['DEPLOY_ENV']).run_script(script_path)
 # Parses kubernetes yml files (supporting multiple documents, Config variables replacement, include secrets).
-#   Sample: DEPLOY_ENV=beta rake kubernetes_helper:run_deployment "deployment.yml" "kubectl create"
+#   Sample: DEPLOY_ENV=beta kubernetes_helper run_deployment "deployment.yml" "kubectl create"
 when 'run_yml'
   output_path = KubernetesHelper.settings_path('tmp_result.yml')
   KubernetesHelper::Core
     .new(ENV['DEPLOY_ENV'])
-    .parse_yml_file(KubernetesHelper.settings_path(ARGV[1]), output_path)
+    .parse_yml_file(KubernetesHelper.settings_path(ARGV[1], use_template: true), output_path)
   KubernetesHelper.run_cmd("#{ARGV[2]} -f #{output_path}")
-
 # Generate template files
-when 'generate'
-  # TODO: ...
-
-# Verify yml files for possible errors.
-#  Sample: DEPLOY_ENV=beta rake kubernetes_helper:verify_yml_files
+when 'generate_templates' #  Sample: kubernetes_helper generate basic
+  mode = ARGV[1] || 'basic'
+  KubernetesHelper.copy_templates(mode)
 when 'verify_yml'
-  # TODO: ...
-
+# Verify yml files for possible errors.
+# TODO: ...
 else
   puts 'Invalid command'
 end

data/lib/kubernetes_helper.rb

@@ -14,15 +14,18 @@ module KubernetesHelper
 
   # @param env_name (String)
   # @return [Hash]
-  def self.load_settings(env_name)
+  def self.load_settings
     config_file = File.join(settings_path, 'settings.rb')
     load config_file
-    settings[env_name.to_sym]
+    settings
   end
 
-  def self.settings_path(file_name = nil)
+  def self.settings_path(file_name = nil, use_template: false)
     path = File.join(Dir.pwd, FOLDER_NAME)
-    path = File.join(path, file_name) if file_name
+    if file_name
+      app_path = File.join(path, file_name)
+      path = use_template && !File.exist?(app_path) ? templates_path(file_name) : app_path
+    end
     path
   end
 
@@ -30,4 +33,20 @@ module KubernetesHelper
     res = Kernel.system cmd
     Kernel.abort("::::::::CD: failed running command: #{title || cmd} ==> #{caller}") if res != true
   end
+
+  def self.templates_path(file_name = nil)
+    path = File.join(File.expand_path(__dir__), 'templates')
+    file_name ? File.join(path, file_name) : path
+  end
+
+  # @param mode (basic, advanced)
+  def self.copy_templates(mode)
+    FileUtils.mkdir(settings_path) unless Dir.exist?(settings_path)
+    files = %w[README.md secrets.yml settings.rb]
+    files += %w[deployment.yml cd.sh ingress.yml service.yml] if mode == 'advanced'
+    files.each do |name|
+      path = settings_path(name)
+      FileUtils.cp(templates_path(name), path) unless File.exist?(path)
+    end
+  end
 end

data/lib/kubernetes_helper/core.rb

@@ -2,20 +2,33 @@
 
 require 'yaml'
 require 'json'
+require 'erb'
+# require 'byebug' rescue nil
+
 module KubernetesHelper
+  class ErbBinding < OpenStruct
+    def get_binding # rubocop:disable Naming/AccessorMethodName:
+      binding
+    end
+
+    def include_template(name)
+      render_template.call(name)
+    end
+  end
+
   class Core
     # @return [Hash]
     attr_accessor :config_values
 
-    # @param env_name (String)
-    def initialize(env_name)
-      env_name = env_name.to_s.length > 1 ? env_name : 'beta'
-      @config_values = KubernetesHelper.load_settings(env_name)
+    # @param _env_name (String)
+    def initialize(_env_name)
+      @config_values = KubernetesHelper.load_settings
     end
 
     def parse_yml_file(file_path, output_path)
       parsed_content = replace_config_variables(File.read(file_path))
-      old_yaml = YAML.load_stream(parsed_content) # rubocop:disable Security/YAMLLoad
+      File.open(output_path, 'w+') { |f| f << parsed_content } # save as draft to be reviewed if failed
+      old_yaml = YAML.load_stream(parsed_content)
       json_data = old_yaml.to_json # fix to skip anchors
       yml_data = JSON.parse(json_data)
       export_documents(yml_data, output_path)
@@ -24,9 +37,13 @@ module KubernetesHelper
     # @param text (String)
     # Sample: replicas: '#{deployment.replicas}'
     def replace_config_variables(text)
-      text.gsub(/(\#{([^}])*})/) do |code|
-        find_setting_value(code.gsub('#{', '').gsub('}', ''))
-      end
+      values = config_values.map do |key, value| # rubocop:disable Style/HashTransformValues
+        [key, value.is_a?(Hash) ? OpenStruct.new(value) : value]
+      end.to_h
+      values[:render_template] = method(:render_template)
+      bind = ErbBinding.new(values).get_binding
+      template = ERB.new(text)
+      template.result(bind)
     end
 
     def run_command(command)
@@ -34,13 +51,13 @@ module KubernetesHelper
       KubernetesHelper.run_cmd(command)
     end
 
-    def run_cd_script(script_path)
+    def run_script(script_path)
       content = replace_config_variables(File.read(script_path))
-      tmp_file = KubernetesHelper.settings_path('tmp_cd.sh')
+      tmp_file = KubernetesHelper.settings_path('tmp_script.sh')
       File.write(tmp_file, content)
       KubernetesHelper.run_cmd("chmod +x #{tmp_file}")
       KubernetesHelper.run_cmd(tmp_file)
-      File.delete(tmp_file)
+      # File.delete(tmp_file) # keep tmp script for analysis purpose
     end
 
     private
@@ -58,20 +75,26 @@ module KubernetesHelper
       end
     end
 
-    # @param setting_key (String)
-    # sample: deployment.replicas
-    def find_setting_value(setting_key)
-      parent = @config_values
-      setting_key.split('.').each do |key|
-        parent = parent[key.to_sym]
+    def render_template(template_name)
+      path = KubernetesHelper.settings_path(template_name, use_template: true)
+      text = "\n#{File.read(path)}"
+      replace_config_variables(text)
+    end
+
+    def static_env_vars
+      (config_values.dig(:deployment, :env_vars) || {}).map do |key, value|
+        {
+          'name' => key.to_s,
+          'value' => value
+        }
       end
-      parent
     end
 
     # parse secrets auto importer
     def parse_import_secrets(document)
       containers = document.dig('spec', 'template', 'spec', 'containers') || []
       containers.each do |container|
+        container['env'] = (container['env'] || []) + static_env_vars
         if container['import_secrets']
           container['env'] = container['env'] + import_secrets(*container['import_secrets'])
           container.delete('import_secrets')
@@ -80,13 +103,21 @@ module KubernetesHelper
     end
 
     def export_documents(yml_data, file_path)
-      documents = yml_data.delete('documents') || Array(yml_data)
       File.open(file_path, 'w+') do |f|
-        documents.each do |document|
+        parse_documents(yml_data).each do |document|
           parse_import_secrets(document)
-          f << document.to_yaml
+          f.write(document.to_yaml)
         end
       end
     end
+
+    # @return [Array<Hash>]
+    def parse_documents(yml_data)
+      documents = []
+      Array(yml_data).each do |document|
+        document['documents'] ? documents.push(*document['documents']) : documents.push(document)
+      end
+      documents
+    end
   end
 end

data/lib/kubernetes_helper/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module KubernetesHelper
-  VERSION = "0.2.1"
+  VERSION = '0.3.3'
 end

data/lib/templates/README.md

@@ -0,0 +1,97 @@
+# Kubernetes app configuration
+
+## Configure a new application environment
+- Create the project on Gcloud
+- Set the project where to work on
+    `gcloud config set project my-project`
+    
+- Create the cluster (Only if not exist)
+    `gcloud container clusters create my-cluster`
+    `# gcloud container clusters list --region europe-west4-a # to list clusters`
+  
+- Use the cluster/project as default
+    `gcloud container clusters get-credentials my-cluster --zone europe-west4-a`
+  
+- Install helper for the next commands
+  `gem install kubernetes_helper`
+  
+- Verify or update k8s settings in .kubernetes/settings.rb
+
+- Register shared cloudsql proxy configuration (only if not exists)
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_command "kubectl create secret generic <%=deployment.cloud_secret_name%> --from-file=credentials.json=<path-to-downloaded/credentials.json>"
+    ```
+    
+- Register manually env vars (values must be encrypted using base64) 
+    Open and register secret values in `.kubernetes/secrets.yml`     
+    Note: Enter base64 encoded values
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_yml 'secrets.yml' 'kubectl create'
+    # kubectl get secrets # to list all secrets registered
+    ```
+
+- Create deployment to run application
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_yml 'deployment.yml' 'kubectl create'
+    # kubectl get deployment # to list deployments
+    ```
+
+- Create service to connect pods and ingress
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_yml 'service.yml' 'kubectl create'
+    # kubectl get services # to list all registered services
+    ```
+
+- Create the public ip address (only if static ip is required)
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_command "gcloud compute addresses create <%=ingress.ip_name%> --global"
+    # gcloud compute addresses list # to list static ips generated
+    # Copy new external ip generated by the previous command and point your domain to it
+    ```
+  
+- Register ingress to receive external http calls (includes ssl certificates if defined)
+    ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_yml 'ingress.yml' 'kubectl create'
+    # kubectl get ingress # to list all registered ingresses
+    # kubectl get ManagedCertificate # to list all certificates
+    # Domain and ssl propagation can take more than 10 minutes
+    # You can start accessing to the app using the generated ip address
+    # `kubectl get ManagedCertificate` # to see the status of ssl provisionning
+    ```
+
+## Apply any k8s setting changes
+- Secrets
+  Open kubernetes secrets and add/edit/remove values and then save it    
+  `kubectl edit secret ...`
+  Once secrets were updated, then restart all related pods, see: https://medium.com/devops-dudes/how-to-propagate-a-change-in-kubernetes-secrets-by-restarting-dependent-pods-b71231827656
+  
+- Other settings
+  ```bash
+    DEPLOY_ENV=beta kubernetes_helper run_yml 'deployment.yml' 'kubectl apply'
+  ```
+
+## Configure continuous deployment for github actions
+* Go to github repository settings
+* Register a new secret variable with content downloaded from https://console.cloud.google.com/iam-admin/serviceaccounts 
+    (Make sure to attach a "Editor", "Storage Admin" and "Kubernetes engine cluster admin" role to the service account)
+  ```bash
+    beta: BETA_CLOUD_TOKEN=<secret content here>
+    production: PROD_CLOUD_TOKEN=<secret content here>
+  ```
+  
+* Add action to run deployment:
+  ```bash
+    env:
+      KB_AUTH_TOKEN: secrets.BETA_CLOUD_TOKEN
+    run: DEPLOY_ENV=beta kubernetes_helper run_deployment 'cd.sh'
+  ``` 
+  
+* Sample:
+  ```yml
+  - run: sudo gem install kubernetes_helper
+  - name: Staging deployment
+    env: # Env variable saved in github that contains gcloud credential (json format)
+      KB_AUTH_TOKEN: ${{ secrets.BETA_GOOGLE_AUTH }}
+    run: DEPLOY_ENV=beta kubernetes_helper run_deployment 'cd.sh'
+    if: ${{ !contains(fromJson('["main", "master"]'), env.DEPLOY_BRANCH) }}
+  ```   

data/lib/templates/_replicas.yml.erb

@@ -0,0 +1,12 @@
+  - apiVersion: autoscaling/v1
+    kind: HorizontalPodAutoscaler
+    metadata:
+      name: <%= "#{deployment.name}-replicas" %>
+    spec:
+      scaleTargetRef:
+        apiVersion: apps/v1
+        kind: Deployment
+        name: <%= deployment.name %>
+      minReplicas: <%= deployment.replicas_range[0] %>
+      maxReplicas: <%= deployment.replicas_range[1] %>
+      targetCPUUtilizationPercentage: 50

data/lib/templates/_sidekiq_alive_gem.yml.erb

@@ -0,0 +1,18 @@
+              ports:
+                - containerPort: &sidekiq_alive_port 7433
+              livenessProbe: &sidekiq_liveness
+                httpGet:
+                  path: /
+                  port: *sidekiq_alive_port
+                initialDelaySeconds: 80 # app specific. Time your sidekiq takes to start processing.
+                timeoutSeconds: 5 # can be much less
+              readinessProbe: *sidekiq_liveness
+              lifecycle:
+                preStop:
+                  exec:
+                    # SIGTERM triggers a quick exit; gracefully terminate instead
+                    command: [
+                        "/bin/bash",
+                        "-c",
+                        "SIDEKIQ_PID=$(ps aux | grep sidekiq | grep busy | awk '{ print $2 }') && kill -SIGTERM $SIDEKIQ_PID",
+                    ]

data/lib/templates/cd.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+set -e
+# expected ENV VAR "KB_AUTH_TOKEN"
+
+SCRIPT_DIR=`dirname "$(realpath -s "$0")"` # app_dir/.kubernetes/
+cd "$SCRIPT_DIR/../" # project directory
+
+DEPLOYMENTS="<%=[deployment.job_name, deployment.name].join(',')%>"
+IMAGE_NAME="<%=continuous_deployment.image_name%>"
+CLUSTER_NAME="<%=continuous_deployment.cluster_name%>"
+PROJECT_NAME="<%=continuous_deployment.project_name%>"
+CLUSTER_REGION="<%=continuous_deployment.cluster_region%>"
+DOCKER_BUILD_CMD="<%=continuous_deployment.docker_build_cmd || 'build -f Dockerfile'%>"
+
+CI_COMMIT_SHA=$(git rev-parse --verify HEAD)
+DEPLOY_NAME="${IMAGE_NAME}:${CI_COMMIT_SHA}"
+LATEST_NAME="${IMAGE_NAME}:latest"
+AUTH_PATH="$SCRIPT_DIR/k8s-auth-token.json"
+
+rm -f -- $AUTH_PATH
+echo $KB_AUTH_TOKEN >> $AUTH_PATH
+
+## ***** GOOGLE CONNECTOR
+# Download and install Google Cloud SDK
+if [ -z "$(which gcloud)" ]; then
+  export CLOUDSDK_CORE_DISABLE_PROMPTS=1; curl https://sdk.cloud.google.com | bash && source /home/runner/google-cloud-sdk/path.bash.inc &&  gcloud --quiet components update kubectl
+fi
+
+# Connect to cluster
+gcloud auth activate-service-account --key-file $AUTH_PATH --project $PROJECT_NAME
+gcloud docker --authorize-only --project $PROJECT_NAME
+gcloud container clusters get-credentials $CLUSTER_NAME --region $CLUSTER_REGION
+## ***** END GOOGLE CONNECTOR
+
+
+## Build and push containers
+docker $DOCKER_BUILD_CMD -t $DEPLOY_NAME .
+docker tag $DEPLOY_NAME $LATEST_NAME
+docker push $DEPLOY_NAME
+docker push $LATEST_NAME
+
+## Apply deployments
+IFS=',' read -r -a deployments <<< "$DEPLOYMENTS"
+for deployment in "${deployments[@]}"; do
+  [ -z "$deployment" ] && continue # if empty value
+
+  kubectl set image deployment/$deployment $deployment=$DEPLOY_NAME
+  [ "$deployment" = "${deployments[0]}" ] && kubectl rollout status deployment/$deployment || true
+done

data/lib/templates/deployment.yml

@@ -0,0 +1,125 @@
+documents:
+  - apiVersion: apps/v1
+    kind: Deployment
+    metadata:
+      name: &app_name <%=deployment.name%>
+    spec: &default_spec
+      replicas: <%=deployment.replicas%>
+      selector:
+        matchLabels:
+          name: *app_name
+      strategy:
+        type: RollingUpdate
+        rollingUpdate:
+          maxSurge: 1
+          maxUnavailable: 1
+      minReadySeconds: 5
+      template:
+        metadata:
+          labels:
+            name: *app_name
+        spec: &template_spec
+          containers:
+            - &app_container
+              image: '<%=continuous_deployment.image_name%>:latest'
+              <% if deployment.command %>
+              command: ["/bin/bash", "-c", "<%= deployment.command %>"]
+              <% end %>
+              name: *app_name
+              import_secrets: ['secrets.yml', '<%=secrets.name%>']
+              ports:
+                - containerPort: &port 3000
+                  name: '<%=service.backend_port_name%>'
+
+              <% if deployment.liveness_path %>
+              livenessProbe: &liveness_probe
+                httpGet:
+                  path: <%=deployment.liveness_path%>
+                  port: *port
+                initialDelaySeconds: 50
+                timeoutSeconds: 3
+                periodSeconds: 15
+              readinessProbe: *liveness_probe
+              <% end %>
+
+              volumeMounts:
+                - &log_volume
+                  name: applog
+                  mountPath: /app/log
+                - &cloud_credentials_volume
+                  name: gcloud-creds
+                  mountPath: /secrets/gcloud
+                  readOnly: true
+
+            - &cloudsql_container
+              image: gcr.io/cloudsql-docker/gce-proxy:1.09 # Cloud sql proxy
+              name: cloudsql-proxy
+              command: ["/cloud_sql_proxy", "--dir=/cloudsql",
+                        "-instances=<%=deployment.cloud_sql_instance%>",
+                        "-credential_file=/secrets/gcloud/credentials.json"]
+              volumeMounts:
+                - *cloud_credentials_volume
+
+            - &logs_container # print to stdout all log files
+              name: print-logs
+              image: busybox
+              command: [/bin/sh, -c, 'until find log/*.log; do sleep 1; done; tail -n+1 -f log/*.log']
+              volumeMounts:
+                - *log_volume
+
+          terminationGracePeriodSeconds: 120
+          volumes:
+            - name: gcloud-creds
+              secret:
+                secretName: '<%=deployment.cloud_secret_name%>'
+            - name: applog
+              emptyDir: {}
+
+  <% if deployment.job_name %>
+  - apiVersion: apps/v1
+    kind: Deployment
+    metadata:
+      name: &job_app_name <%=deployment.job_name%>
+    spec:
+      <<: *default_spec
+      replicas: 1
+      selector:
+        matchLabels:
+          name: *job_app_name
+      template:
+        metadata:
+          labels:
+            name: *job_app_name
+        spec:
+          <<: *template_spec
+          containers:
+            - <<: *app_container
+              name: *job_app_name
+              <% if deployment.job_command %>
+              command: [ "/bin/bash", "-c", "<%= deployment.job_command %>" ]
+              <% end %>
+
+            <% if deployment.job_sidekiq_alive_gem %>
+              <%= include_template "_sidekiq_alive_gem.yml.erb" %>
+            <% else %>
+              ports: [ ]
+              <% if (deployment.job_services || []).any? %>
+              livenessProbe: &liveness_probe
+                exec:
+                  command: [ /bin/sh, -c,
+                      'if [ $(ps -ef | grep "<%= deployment.job_services.join("\|") %>" | grep -v "grep" | wc -l) -lt <%= deployment.job_services.count %> ]; then
+                           echo "Some required services are not running"; exit 1;
+                       fi' ]
+                initialDelaySeconds: 120
+                periodSeconds: 30
+              readinessProbe: *liveness_probe
+              <% end %>
+            <% end %>
+
+            - *cloudsql_container
+            - <<: *logs_container
+  <% end %>
+
+  <% if deployment.replicas_range %>
+  <%= include_template "_replicas.yml.erb" %>
+  <% end %>

data/lib/templates/ingress.yml

@@ -0,0 +1,33 @@
+<% if ingress.domain_name %>
+apiVersion: networking.gke.io/v1beta1
+kind: ManagedCertificate
+metadata:
+  name: '<%=ingress.certificate_name%>'
+spec:
+  domains: # does not support for willcard domains
+    - '<%=ingress.domain_name%>'
+<% end %>
+
+---
+
+apiVersion: extensions/v1beta1
+kind: Ingress
+metadata:
+  name: '<%=ingress.name%>'
+  annotations:
+    kubernetes.io/ingress.class: "gce"
+    kubernetes.io/ingress.allow-http: "true"
+    ingress.kubernetes.io/ssl-redirect: "true"
+
+    <% if ingress.ip_name %>
+    kubernetes.io/ingress.global-static-ip-name: "<%=ingress.ip_name%>"
+    <% end %>
+
+    <% if ingress.domain_name %>
+    networking.gke.io/managed-certificates: '<%=ingress.certificate_name%>'
+    <% end %>
+
+spec:
+  backend:
+    serviceName: '<%=service.name%>'
+    servicePort: '<%=service.port_name%>'

data/lib/templates/secrets.yml

@@ -0,0 +1,11 @@
+# Every Value has to be base64 encoded
+# IMPORTANT: For security reason, never ever commit secret values, only keys
+
+apiVersion: v1
+kind: Secret
+metadata:
+  name: '<%=secrets.name%>'
+type: Opaque
+data:
+  my_key1: "based_64_value_encoded"
+  my_key2: "based_64_value_encoded"

data/lib/templates/service.yml

@@ -0,0 +1,27 @@
+---
+# used to increase request timeout
+apiVersion: cloud.google.com/v1beta1
+kind: BackendConfig
+metadata:
+  name: '<%=service.config_name%>'
+spec:
+  timeoutSec: 1800
+
+---
+
+
+kind: Service
+apiVersion: v1
+metadata:
+  name: '<%=service.name%>'
+  annotations:
+    beta.cloud.google.com/backend-config: '{"ports": {"80":"<%=service.config_name%>"}}'
+spec:
+  selector:
+    name: '<%=deployment.name%>'
+  type: NodePort
+  ports:
+    - port: 80
+      protocol: TCP
+      name: '<%=service.port_name%>'
+      targetPort: '<%=service.backend_port_name%>'

data/lib/templates/settings.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+is_production = ENV['DEPLOY_ENV'] == 'production'
+app_name = is_production ? 'my_app' : 'my_beta_app'
+settings = {
+  deployment: {
+    name: app_name,
+    replicas: is_production ? 2 : 1,
+    cloud_secret_name: "#{is_production ? 'production' : 'beta'}-cloud-secret",
+    cloud_sql_instance: 'xxx:xxx:xxx=tcp:5432', # 5432 => postgres, 3306 => mysql
+    env_vars: {}, # Sample: { 'CUSTOM_VAR' => 'value' }
+    # command: '', # custom container command (default empty to be managed by Dockerfile)
+    # liveness_path: '/check_liveness', # nil if not exist
+    # job_name: "#{app_name}-job", # enable if there is any background service
+    # job_command: 'bundle exec sidekiq -C config/sidekiq.yml',
+    # job_services: ['sidekiq', 'cron'] # list of linux services needed.
+  },
+  ingress: {
+    name: "#{app_name}-ingress",
+    ip_name: "#{app_name}-static-ip", # nil if static ip is not necessary
+    certificate_name: "#{app_name}-lets-encrypt", # nil if ssl is not required
+    domain_name: is_production ? 'myapp.com' : 'beta.myapp.com' # nil if domain is not required
+  },
+  continuous_deployment: {
+    image_name: "gcr.io/my-account/#{app_name}",
+    project_name: 'my-project-name',
+    cluster_name: 'my-cluster-name',
+    cluster_region: 'europe-west4-a',
+    docker_build_cmd: 'build -f Dockerfile'
+  },
+  secrets: {
+    name: "#{app_name}-secrets"
+  },
+  service: {
+    name: app_name,
+    port_name: 'http-port', # max 15 characters
+    backend_port_name: 'b-port', # max 15 characters
+    config_name: "#{app_name}-backend-config"
+  }
+}
+
+KubernetesHelper.settings(settings)

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: kubernetes_helper
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.3
 platform: ruby
 authors:
 - owen2345
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-19 00:00:00.000000000 Z
-dependencies: []
+date: 2021-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: erb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
 - owenperedo@gmail.com
@@ -25,6 +39,15 @@ files:
 - lib/kubernetes_helper/core.rb
 - lib/kubernetes_helper/railtie.rb
 - lib/kubernetes_helper/version.rb
+- lib/templates/README.md
+- lib/templates/_replicas.yml.erb
+- lib/templates/_sidekiq_alive_gem.yml.erb
+- lib/templates/cd.sh
+- lib/templates/deployment.yml
+- lib/templates/ingress.yml
+- lib/templates/secrets.yml
+- lib/templates/service.yml
+- lib/templates/settings.rb
 homepage: https://github.com/owen2345/kubernetes_helper
 licenses:
 - MIT