initial commit

Author: jaxxstorm

.github/workflows/release.yml

@@ -0,0 +1,25 @@
+name: release
+on:
+  push:
+    tags: [ v*.*.** ] # only a valid semver tag
+
+jobs:    
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Unshallow clone
+        run: git fetch --prune --unshallow
+      - name: Install Go 1.14
+        uses: actions/setup-go@v2
+        with:
+          go-version: '1.14.x'
+      - name: Goreleaser publish
+        uses: goreleaser/goreleaser-action@v1
+        with:
+          version: v0.145.0
+          args: release --rm-dist
+        env:
+        env:
+          GITHUB_TOKEN: ${{ secrets.ACTIONS_TOKEN }}

.gitignore

@@ -13,3 +13,6 @@
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# ide
+.idea/

.goreleaser.yml

@@ -0,0 +1,39 @@
+before:
+  hooks:
+    - go mod download
+builds:
+- env:
+  - CGO_ENABLED=0
+  - GO111MODULE=on
+  goos:
+    - darwin
+    - windows
+    - linux
+  goarch:
+    - amd64
+  ldflags: -X github.com/jaxxstorm/ploy/pkg/version.Version={{.Version}}
+  binary: ploy
+  main: ./cmd/ploy/main.go
+archives:
+- name_template: "{{ .Binary }}-{{ .Tag }}-{{ .Os }}-{{ .Arch }}"
+  format_overrides:
+    - goos: windows
+      format: zip
+snapshot:
+  name_template: "{{ .Tag }}-SNAPSHOT"
+changelog:
+  skip: true
+release:
+  prerelease: auto
+brews:
+  - 
+    name: ploy
+    github:
+      owner: jaxxstorm
+      name: homebrew-tap
+    commit_author:
+      name: GitHub Actions
+      email: [email protected]
+    folder: Formula
+    homepage: "https://leebriggs.co.uk"
+    description: "Quickly install applications to Kubernetes with Pulumi"

README.md

@@ -1 +1,107 @@
-# ploy
+# Ploy - straightforward Kubernetes deployment
+
+Ploy is a proof of concept tool that will deploy a Docker image on your machine locally to a Kubernetes cluster.
+
+It was inspired by [Halloumi](https://github.com/pulumi/halloumi) and its purpose is to show how easy it is to create useful developer tooling with the [Pulumi](https://pulumi.com/) [Automation API](https://pkg.go.dev/github.com/pulumi/pulumi/sdk/v2/go/x/auto)
+
+It provides a Heroku like experience for uses deploying Docker images.
+
+It is currently designed to work exclusively with AWS EKS, but support for other providers could be added.
+
+## Installation
+
+
+
+## Usage
+
+Ploy take a Docker context with a `Dockerfile`, builds it locally and pushes it to an [ECR repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html).
+
+Each ploy application is deployed as a pulumi stack within a project called `ploy` in your configured Pulumi organization (see [configuration](##configuration))
+
+Once the image is pushed, it creates a Kubernetes namespace, Deployment and Service with an external load balancer.
+
+Here's what it looks like:
+
+### Deploy
+
+```bash
+ploy up
+INFO[0002] Creating application: regularly-viable-stud
+INFO[0002] Creating ECR repository
+INFO[0002] Creating local docker image
+INFO[0002] Creating Kubernetes namespace
+INFO[0002] Creating Kubernetes deployment
+INFO[0002] Creating Kubernetes service
+INFO[0004] Repository created: 616138583583.dkr.ecr.us-west-2.amazonaws.com/regularly-viable-stud-e23717a
+INFO[0034] Your service is available at: aedc7304ebcf648baa881cf4069e5aad-354579065.us-west-2.elb.amazonaws.com
+```
+
+Ploy deploys your application to the Kubernetes cluster currently configured in your `KUBECONFIG`. It creates the ECR repository using the AWS credentials you're currently using, whether that be an aws profile or aws keys.
+
+_note:_ Your EKS cluster must have access to ECR for the image to be pulled. See [here](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ECR_on_EKS.html) for more details.
+
+You can optionally set an explicit name for your application by passing it as an argument:
+
+```bash
+ploy up my-app
+```
+
+### Retrieve
+
+You can grab a list of the currently deployed ploy applications using the `get` command:
+
+```bash
+ploy get
++--------------------------+--------------------------+----------------------------------------------------------------+-------------------------------------------------------------------------------+
+|           NAME           |       LAST UPDATE        |                        DEPLOYMENT INFO                         |                                      URL                                      |
++--------------------------+--------------------------+----------------------------------------------------------------+-------------------------------------------------------------------------------+
+| frequently-better-beagle | 2020-11-03T19:06:36.000Z | https://app.pulumi.com/jaxxstorm/ploy/frequently-better-beagle | http://a9027e3626d3a41a78e600ab832991d3-975080570.us-west-2.elb.amazonaws.com |
+| regularly-viable-stud    | 2020-11-03T19:41:19.000Z | https://app.pulumi.com/jaxxstorm/ploy/regularly-viable-stud    | http://aedc7304ebcf648baa881cf4069e5aad-354579065.us-west-2.elb.amazonaws.com |
++--------------------------+--------------------------+----------------------------------------------------------------+-------------------------------------------------------------------------------+
+```
+
+### Destroy
+
+You can tear down your `ploy` application with the `destroy` command:
+
+```bash
+ploy destroy
+```
+
+## Configuration
+
+Ploy's only required configuration value is your Pulumi org. You can specify it on the command line:
+
+### Organization
+
+```bash
+ploy up -o jaxxstorm
+```
+
+Or alternatively, set it in your ploy configuration file:
+
+```yaml
+cat ~/.ploy/config.yml
+org: jaxxstorm
+```
+
+### Region
+
+You'll need to set the AWS region you want to use for your ECR repository. You can set it on the command line:
+
+```bash
+ploy up -r us-west-2
+```
+
+Via configuration:
+
+```yaml
+cat ~/.ploy/config.yml
+region: us-west-2
+```
+
+Or alternatively, it'll read your `AWS_REGION` environment variable:
+
+```
+export AWS_REGION=us-west-2
+```

cmd/ploy/destroy/cli.go

@@ -0,0 +1,115 @@
+package destroy
+
+import (
+	"context"
+	"fmt"
+	"github.com/manifoldco/promptui"
+	"github.com/pulumi/pulumi/sdk/v2/go/x/auto"
+	"github.com/pulumi/pulumi/sdk/v2/go/x/auto/optdestroy"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"io/ioutil"
+	"os"
+)
+
+var (
+	dryrun    bool
+	name      string
+	directory string
+	verbose   bool
+)
+
+func Command() *cobra.Command {
+	command := &cobra.Command{
+		Use:   "destroy",
+		Short: "Remove your application",
+		Long:  "Remove your application from Kubernetes",
+		Args: cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+
+			ctx := context.Background()
+			org := viper.GetString("org")
+			region := viper.GetString("region")
+			name := args[0]
+
+			if org == "" {
+				return fmt.Errorf("must specify pulumi org via flag or config file")
+			}
+
+			label := fmt.Sprintf("This will delete the application %s. Are you sure you wish to continue?", name)
+
+			prompt := promptui.Prompt{
+				Label:     label,
+				IsConfirm: true,
+			}
+
+			result, err := prompt.Run()
+
+			if err != nil {
+				fmt.Printf("User cancelled, not deleting %v\n", err)
+				os.Exit(0)
+			}
+
+			log.Debug("User confirmed, continuing: %s", result)
+			log.Infof("Deleting application: %s", name)
+
+			// create a stack in our backend
+			stackName := auto.FullyQualifiedStackName(org, "ploy", name)
+			// create a stack. We'll set the program shortly
+			pulumiStack, err := auto.UpsertStackInlineSource(ctx, stackName, "ploy", nil)
+			if err != nil {
+				return fmt.Errorf("failed to create or select stack: %v\n", err)
+			}
+
+			// set the AWS region from config
+			err = pulumiStack.SetConfig(ctx, "aws:region", auto.ConfigValue{Value: region})
+			if err != nil {
+				return err
+			}
+
+			// set up workspace and install plugins
+			workspace := pulumiStack.Workspace()
+			err = workspace.InstallPlugin(ctx, "aws", "v3.11.0")
+			if err != nil {
+				return fmt.Errorf("error installing aws plugin: %v\n", err)
+			}
+			err = workspace.InstallPlugin(ctx, "kubernetes", "v2.6.3")
+			if err != nil {
+				return fmt.Errorf("error installing kubernetes plugin: %v\n", err)
+			}
+			err = workspace.InstallPlugin(ctx, "docker", "v2.4.0")
+			if err != nil {
+				return fmt.Errorf("error installing docker plugin: %v\n", err)
+			}
+
+			var streamer optdestroy.Option
+			if verbose {
+				streamer = optdestroy.ProgressStreams(os.Stdout)
+			} else {
+				streamer = optdestroy.ProgressStreams(ioutil.Discard)
+			}
+			_, err = pulumiStack.Destroy(ctx, streamer)
+
+			if err != nil {
+				return fmt.Errorf("error deleting stack resources: %v", err)
+			}
+
+			// destroy the stack so it's no longer listed
+			// Then we delete the stack from earlier so we don't include it in our list
+			workspace.RemoveStack(ctx, name)
+
+			return nil
+
+		},
+	}
+	f := command.Flags()
+	f.BoolVarP(&dryrun, "preview", "p", false, "Preview changes, dry-run mode")
+	f.BoolVarP(&verbose, "verbose", "v", false, "Show output of Pulumi operations")
+	f.StringVarP(&directory, "dir", "d", ".", "Path to docker context to use")
+
+	viper.BindPFlag("stack", command.Flags().Lookup("stack"))
+
+	cobra.MarkFlagRequired(f, "name")
+	return command
+}

cmd/ploy/get/cli.go

@@ -0,0 +1,87 @@
+package get
+
+import (
+	"context"
+	"fmt"
+	n "github.com/jaxxstorm/ploy/pkg/name"
+	"github.com/olekukonko/tablewriter"
+	"github.com/pulumi/pulumi/sdk/v2/go/x/auto"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"os"
+)
+
+func Command() *cobra.Command {
+	command := &cobra.Command{
+		Use:   "get",
+		Short: "Get all ploy deployed applications",
+		Long:  "Get all ploy deployed applications",
+		RunE: func(cmd *cobra.Command, args []string) error {
+
+			// Required params
+			ctx := context.Background()
+			org := viper.GetString("org")
+
+			if org == "" {
+				return fmt.Errorf("must specify pulumi org via flag or config file")
+			}
+
+			// Generate a random name to use
+			name := n.GenerateName()
+
+			/*
+			 * This is a little hacky, but it works.
+			 * I don't want to have to manage the workspaces myself, so I generate a stack name randomly
+			 */
+			stackName := auto.FullyQualifiedStackName(org, "ploy", name)
+			// Create a stack. We never set the program, we're not going to use it
+			pulumiStack, err := auto.UpsertStackInlineSource(ctx, stackName, "ploy", nil)
+			if err != nil {
+				return fmt.Errorf("failed to create or select stack: %v\n", err)
+			}
+
+			workspace := pulumiStack.Workspace()
+
+			// Then we delete the stack from earlier so we don't include it in our list
+			workspace.RemoveStack(ctx, name)
+
+			// List the stacks in our workspace, each stack is an instance of an app
+			stackList, err := workspace.ListStacks(ctx)
+			if err != nil {
+				return fmt.Errorf("failed to list available stacks: %v\n", err)
+			}
+
+			if len(stackList) > 0 {
+
+				// Build a pretty table!
+				table := tablewriter.NewWriter(os.Stdout)
+				table.SetHeader([]string{"Name", "Last Update", "Deployment Info", "URL"})
+
+				// Loop through all the values in the returned stacks and add them to a string array
+				for _, values := range stackList {
+
+					// loop through all the stacks to retrieve the stack outputs
+					stackName := auto.FullyQualifiedStackName(org, "ploy", values.Name)
+					stack, err := auto.SelectStack(ctx, stackName, workspace)
+					if err != nil {
+						return fmt.Errorf("error selecting stack")
+					}
+					out, err := stack.Outputs(ctx)
+
+					// add all the values to the output tables
+					table.Append([]string{values.Name, values.LastUpdate, values.URL, fmt.Sprintf("http://%s", out["address"].Value.(string))})
+				}
+
+				// Render the table to stdout
+				table.Render()
+			} else {
+				log.Info("No ploy apps currently deployed")
+			}
+
+			return nil
+		},
+	}
+
+	return command
+}