Update to use SAM Pipelines (#90)

* Sam pipelines (#80)

* Updated bootstrap script for Amazon Linux 2

* Update setup instructions for AL2

Why
---

- Some instructions needed updating for the AL2 bootstrap script

How
---

- Using text code snippets is simpler and easier to update than
screenshots.
- Update the boostrap steps with the new behavior of `bootstrap.sh` on
AL2

Next Steps
----------

- Cleanup/remove old screenshots
- Add steps and instructions to use SAM Pipelines

* Updates to include SAM Pipelines

- Added Chapter 4 which covers SAM Pipelines
- Updated Formatting
- Removing/updating some screenshots

Co-authored-by: Matt Diamond <matt.d.diamond@hotmail.com>

* feat(csharp): add csharp workshop content

* fix(csharp): update setup links

* Added codeowners file

* renamed codeowners file

* SAM Pipeline updates and reuse Hugo content

What
-----

- SAM Pipelines needed some better explaining and diagrams
- There are many sections that are the same between languages. Create a
custom Hugo snippet to share templates across languages.

How
----

- Add in-depth explanation and walk through of SAM Pipelines
- Update many other sections with minor copy edits and formatting.
- Removed all references to the CDK build steps
- Move _many_ screenshots to plain text, which will be easier to update
and maintain
- Update `bootstrap.sh` to work with AL2

Next
------

- Finish the canary deployment for JS. Update the SAM/CFN template to
only use gradual deployment only for production stack.
- Left off at the Rolbacks sections. Finish off that one and show how
,with the canary deployment enabled only on `prod`, the dev stack is
updated but prod is rolled back.
- Remove outdated files in other languages
- Double check all of the menus for different languages and make sure
they align
- In further-future, it would makse sense to move to a _single_ workshop
with one set of steps, and treat each language different in the same
section so students could follow their language of choice within a
single part of the lab. This would make maintainability much easier, and
the flow of the workshop improved.
- Update the cleanup steps

* Add section on enabling unit tests

* Updates for Python version.

Why
---

- Get the Python pipeline section more in-line with the JS version.

How
---

- Remove legacy section from Python
- Update bootstrap script to work around a new error during updating.
- Add a `.gitignore` step

Next Steps
----------

-

* Updated testing instructions for python

* update tests instructions for all languages

* Update canary steps with different config for dev/prod

* one small fix for python3.7

* Add c# and java unit test instructions

* Use latest version of learn theme

* Updates to get Python/Node into one flow

Why
---

- Maintaining four languages is a lot of overhead. Having a single flow
  of the workshop using tabs where appropriate is much simpler.

How
---

- Use `tabs` to split Python/Node specifics, for the Lambda function
- Update lots of content for accuracy
- Update some screenshots

* Update section on auto rollback

* Move to a single set of instructions for Python/Node

* Update internal reference

* Finish the cleanup section

* Update to metadata, README and add appendix

* Update codeowner to GH username

Co-authored-by: Matt Diamond <matt.d.diamond@hotmail.com>
Co-authored-by: Kevin Hakanson <kevhak@amazon.com>
Co-authored-by: Fernando Dingler <fdingler@amazon.com>

Author: 4 people

CODEOWNERS

@@ -0,0 +1,8 @@
+# This is a comment.
+# Each line is a file pattern followed by one or more owners.
+
+# These owners will be the default owners for everything in
+# the repo. Unless a later match takes precedence,
+# Owners will be requested for review when someone opens a PR.
+
+*       @brianz @ferdingler

README.md

@@ -1,6 +1,18 @@
 # CI/CD for Serverless Applications Workshop
 
-In this workshop, you will learn how to start a new Serverless application from scratch using the AWS Serverless Application Model (AWS SAM) and how to fully automate builds and deployments by building a continous delivery pipeline using the AWS CDK. You will also learn how to run a Serverless application locally using the SAM CLI.
+In this workshop, you will learn how to start a new Serverless application from scratch using the 
+AWS Serverless Application Model (AWS SAM) and how to fully automate builds and deployments. You
+will bootstrap a fully-automated CI/CD pipeline using 
+[SAM Pipelines](https://aws.amazon.com/blogs/compute/introducing-aws-sam-pipelines-automatically-generate-deployment-pipelines-for-serverless-applications/). 
+At the end of the workshop you will have a self-updating pipeline which 
+
+1. Deploys two stages, `dev` and `prod`
+1. Runs unit tests
+1. Deploys gradually using canary deployments
+1. Monitors for errors
+1. Aborts deployments when errors occur
+
+You will also learn how to run a Serverless application locally using the SAM CLI
 
 ![Image](workshop/static/images/github-home.svg)
 
@@ -10,12 +22,15 @@ Visit the workshop on this URL: [https://cicd.serverlessworkshops.io](https://ci
 
 ## Older workshop versions
 
-This workshop has been evolving thanks to community contributions, but we are keeping older versions in case you prefer them. Every major update, we create a branch with the old version and we make it available in the following URLs, so feel free to use them: 
+This workshop has been evolving thanks to community contributions. We keep older versions for those
+who prefer different approaches for creating CI/CD pipelines.
+Every major update, we create a branch with the old version and make it available in the following URLs:
 
 | Version  | Description | URL |
 | ------------- | ------------- | ------------- |
 | v1  | Raw cloudformation, no CDK  | [https://v1.cicd.serverlessworkshops.io](https://v1.cicd.serverlessworkshops.io) |
 | v2  | No multi-language, javascript only | [https://v2.cicd.serverlessworkshops.io](https://v2.cicd.serverlessworkshops.io) |
+| v3  | CDK, without SAM Pipelines | [https://v3.cicd.serverlessworkshops.io](https://v3.cicd.serverlessworkshops.io) |
 
 ## Want to contribute?
 

amplify.yml

@@ -3,7 +3,7 @@ frontend:
   phases:
     build:
       commands:
-        - git clone --branch 2.4.0 https://github.com/matcornic/hugo-theme-learn.git workshop/themes/learn
+        - git clone --depth=1 https://github.com/matcornic/hugo-theme-learn.git workshop/themes/learn
         - hugo --source workshop --destination ../public --quiet
   artifacts:
     baseDirectory: /public

metadata.yml

@@ -5,28 +5,28 @@ title: CI/CD for Serverless Applications
 #description - A short description that will be displayed in search results
 description: In this workshop, you will learn how to start a new Serverless application from scratch using the AWS Serverless Application Model (AWS SAM) and how to fully automate builds and deployments by building a continous delivery pipeline using AWS CodeCommit, AWS CodeBuild and AWS CodePipeline. You will also learn how to test a Serverless application locally using the SAM CLI.
 #categories - Refer to official AWS categories covered by the workshop content here
-categories: 
+categories:
   - Serverless
   - Lambda
   - Continous Delivery
   - Automation
   - SAM
 #services - Refer to the official AWS service names covered by the workshop content here
-services: 
+services:
    - API Gateway
    - Lambda
    - CodePipeline
    - CodeCommit
    - CodeBuild
    - CloudFormation
 #level - Approximate skill level needed for this workshop
-level: 300 
+level: 300
 #duration - Estimated duration in minutes
-duration: 120 
+duration: 120
 #cost - Cost in USD. If the content is offered without cost, enter 0
-cost: 0 
+cost: 0
 #author - Amazon alias of the primary author of the content
-author: fdingler 
+author: zambb
 #audience - Names of the personas associated with this workshop
-audience: 
-  - Developer
+audience:
+  - Developer

workshop/config.toml

@@ -16,7 +16,7 @@ pygmentsStyle = "monokai"
 [params]
   editURL = "https://github.com/aws-samples/aws-serverless-cicd-workshop/tree/master/workshop/content/"
   description = "Building a CI/CD pipeline for Serverless applications"
-  author = "Fernando Dingler <fdingler@amazon.com>"
+  author = "Brian Zambrano <zambb@amazon.com"
   disableBreadcrumb = false
   disableNextPrev = false
   themeVariant = "aws"
@@ -37,4 +37,4 @@ hrefTargetBlank = true
 [Languages.en]
 title = ""
 weight = 1
-languageName = "English"
+languageName = "English"

workshop/content/_index.en.md

@@ -3,16 +3,21 @@ title = "CI/CD for Serverless Applications"
 chapter = true
 weight = 1
 +++
+
 # CI/CD for Serverless Applications
 
-In this workshop, you will learn how to start a new Serverless application from scratch using the AWS Serverless Application Model (AWS SAM) and how to fully automate builds and deployments by building a continous delivery pipeline using the AWS CDK. You will also learn how to run a Serverless application locally using the SAM CLI.
+In this workshop, you will learn how to start a new Serverless application from scratch using the
+AWS Serverless Application Model (AWS SAM) and how to fully automate builds and deployments.
+You will use a feature of SAM called SAM Pipelines to bootstrap a continous delivery pipeline. You
+will also learn how to run a serverless application locally using the SAM CLI.
 
 ![Intro](/images/github-home.svg)
 
 ### Issues, Comments, Feedback?
 
-I’m open source! If you see an issue, want to contribute content, or have overall feedback please open an issue or pull request in our GitHub repository: [github.com/aws-samples/aws-serverless-cicd-workshop](https://github.com/aws-samples/aws-serverless-cicd-workshop).
-
+I’m open source! If you see an issue, want to contribute content, or have overall feedback please
+open an issue or pull request in our GitHub repository:
+[github.com/aws-samples/aws-serverless-cicd-workshop](https://github.com/aws-samples/aws-serverless-cicd-workshop).
 
 {{% button href="https://github.com/aws-samples/aws-serverless-cicd-workshop/issues" icon="fas fa-bug" %}}Report an issue{{% /button %}}
-{{% button href="https://aws.amazon.com/serverless/developer-tools" icon="fas fa-graduation-cap" %}}Learn more{{% /button %}}
+{{% button href="https://aws.amazon.com/serverless/developer-tools" icon="fas fa-graduation-cap" %}}Learn more{{% /button %}}

workshop/content/appendix/_index.en.md

@@ -0,0 +1,163 @@
++++
+title = "Appendix"
+date = 2020-07-06T17:49:47-04:00
+weight = 1000
+pre = "<b>7. </b>"
++++
+
+Prior versions of this workshop used the AWS CDK to create the CI/CD pipeline. CDK is a fantastic
+tool! If you are looking for the CDK version, below is an example CI/CD pipeline in TypeScript using
+CDK V2.
+
+Note that this example from `v3` of this workshop is missing a few features compared to the one setup by
+SAM Pipelines. It does not have a specific unit test phase and does not self-update.
+
+```typescript
+import { Stack, StackProps } from "aws-cdk-lib"
+import { Construct } from "constructs"
+
+import * as codebuild from "aws-cdk-lib/aws-codebuild"
+import * as codecommit from "aws-cdk-lib/aws-codecommit"
+import * as codepipeline from "aws-cdk-lib/aws-codepipeline"
+import * as codepipeline_actions from "aws-cdk-lib/aws-codepipeline-actions"
+import * as s3 from "aws-cdk-lib/aws-s3"
+
+export class ServerlessCicdPipelineStack extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props)
+
+    const artifactsBucket = new s3.Bucket(this, "ArtifactsBucket")
+
+    const codeRepo = codecommit.Repository.fromRepositoryName(this, "AppRepository", "sam-app")
+    // Pipeline creation starts
+    const pipeline = new codepipeline.Pipeline(this, "Pipeline", {
+      artifactBucket: artifactsBucket,
+    })
+
+    // Declare source code as an artifact
+    const sourceOutput = new codepipeline.Artifact()
+
+    // Add source stage to pipeline
+    pipeline.addStage({
+      stageName: "Source",
+      actions: [
+        new codepipeline_actions.CodeCommitSourceAction({
+          actionName: "CodeCommit_Source",
+          repository: codeRepo,
+          output: sourceOutput,
+          branch: "main",
+        }),
+      ],
+    })
+
+    // Declare build output as artifacts
+    const buildOutput = new codepipeline.Artifact()
+
+    // Declare a new CodeBuild project
+    const buildProject = new codebuild.PipelineProject(this, "Build", {
+      environment: { buildImage: codebuild.LinuxBuildImage.AMAZON_LINUX_2_2 },
+      environmentVariables: {
+        PACKAGE_BUCKET: {
+          value: artifactsBucket.bucketName,
+        },
+      },
+    })
+
+    // Add the build stage to our pipeline
+    pipeline.addStage({
+      stageName: "Build",
+      actions: [
+        new codepipeline_actions.CodeBuildAction({
+          actionName: "Build",
+          project: buildProject,
+          input: sourceOutput,
+          outputs: [buildOutput],
+        }),
+      ],
+    })
+
+    // Prod stage
+    pipeline.addStage({
+      stageName: "Dev",
+      actions: [
+        new codepipeline_actions.CloudFormationCreateReplaceChangeSetAction({
+          actionName: "CreateChangeSet",
+          templatePath: buildOutput.atPath("packaged.yaml"),
+          stackName: "sam-app-dev",
+          adminPermissions: true,
+          changeSetName: "sam-app-dev-changeset",
+          runOrder: 1,
+        }),
+        new codepipeline_actions.CloudFormationExecuteChangeSetAction({
+          actionName: "Deploy",
+          stackName: "sam-app-dev",
+          changeSetName: "sam-app-dev-changeset",
+          runOrder: 2,
+        }),
+      ],
+    })
+
+    // Production stage
+    pipeline.addStage({
+      stageName: "Prod",
+      actions: [
+        new codepipeline_actions.CloudFormationCreateReplaceChangeSetAction({
+          actionName: "CreateChangeSet",
+          templatePath: buildOutput.atPath("packaged.yaml"),
+          stackName: "sam-app-prod",
+          adminPermissions: true,
+          changeSetName: "sam-app-prod-changeset",
+          runOrder: 1,
+        }),
+        new codepipeline_actions.CloudFormationExecuteChangeSetAction({
+          actionName: "Deploy",
+          stackName: "sam-app-prod",
+          changeSetName: "sam-app-prod-changeset",
+          runOrder: 2,
+        }),
+      ],
+    })
+  }
+}
+```
+
+The following `buildspec.yml` file shows how to build and test a Node AWS SAM application with the
+pipeline above. It's possible to extract the test command into it's own pipeline stage so that tests
+are run once rather than per-stage.
+
+```yaml
+# sam-app/buildspec.yml
+version: 0.2
+phases:
+  install:
+    runtime-versions:
+      nodejs: 12
+    commands:
+      # Install packages or any pre-reqs in this phase.
+      # Upgrading SAM CLI to latest version
+      - pip3 install --upgrade aws-sam-cli
+      - sam --version
+      - cd hello-world
+      - npm install
+
+  pre_build:
+    commands:
+      - npm run test
+
+  build:
+    commands:
+      # Use Build phase to build your artifacts (compile, etc.)
+      - cd ..
+      - sam build
+
+  post_build:
+    commands:
+      # Use Post-Build for notifications, git tags, upload artifacts to S3
+      - sam package --s3-bucket $PACKAGE_BUCKET --output-template-file packaged.yaml
+
+artifacts:
+  discard-paths: yes
+  files:
+    # List of local artifacts that will be passed down the pipeline
+    - packaged.yaml
+```

workshop/content/buildpipe/_index.en.md

@@ -0,0 +1,19 @@
++++
+title = "Build the pipeline"
+date = 2019-10-03T14:25:05-07:00
+weight = 25
+chapter = true
+pre = "<b>4. </b>"
++++
+
+# Build the pipeline
+
+In this chapter you are going to learn how to automate the build, package and deploy commands by
+creating a continous delivery pipeline using AWS Code Pipeline. We will be using [SAM
+Pipelines](https://aws.amazon.com/blogs/compute/introducing-aws-sam-pipelines-automatically-generate-deployment-pipelines-for-serverless-applications/)
+to generate and a self-updating, multi-stage CI/CD pipeline.
+
+![SimplePipeline](/images/pipeline-art.png)
+
+The services used in this chapter, via SAM Pipelines are CodeCommit, CodeBuild, CodePipeline and
+CloudFormation.

workshop/content/java/buildpipe/credhelper/_index.en.md renamed to workshop/content/buildpipe/credhelper/_index.en.md

@@ -6,13 +6,27 @@ weight = 10
 
 One of the cool things about CodeCommit is the support for IAM authentication. And if you are running this workshop from a Cloud9 workspace, you can leverage the fact that your terminal is already pre-authenticated with valid AWS credentials.
 
-Configure the git client with username and email, so your commits have an author defined.
+You can validate the Cloud9 git configuration with the following command:
 
 ```
-git config --global user.name "Replace with your name"
-git config --global user.email "replace_with_your_email@example.com"
+git config --get-regexp credential\.*
+```
+
+You should see the following
+
 ```
+credential.helper !aws codecommit credential-helper $@
+credential.usehttppath true
+```
+
+If you are running this workshop outside Cloud9 or do **not** see the same credential configuation
+above, refer to the [CodeCommit
+Authentication](https://docs.aws.amazon.com/codecommit/latest/userguide/auth-and-access-control.html)
+documentation.
 
-Example:
+Configure the git client with username and email, so your commits have an author defined.
 
-![CredsHelper](/images/java/chapter4/credhelper/cred-helper.png)
+```text
+git config --global user.name "Replace with your name"
+git config --global user.email "replace_with_your_email@example.com"
+```

workshop/content/buildpipe/done/_index.en.md

@@ -0,0 +1,41 @@
++++
+title = "Inspect pipeline"
+date = 2019-11-05T14:20:52-08:00
+weight = 35
++++
+
+### Inspect the pipeline
+
+Once the `sam-app-pipeline` CloudFormation stack has completed, you will have a new CodePipeline Pipeline.
+Navigate to the [CodePipeline Console](https://console.aws.amazon.com/codesuite/codepipeline/pipelines).
+You should see a single Pipeline. If you've navigated here soon after deploying the pipeline
+CloudFormation stack, you will see your new Pipeline exeuting its first deployment.
+
+![Pipeline in-progress](/images/chapter4-pipelines/sam-app-pipeline-in-progress.png)
+
+Let your pipeline run every stage. After it finishes all stages will be green.
+
+![Pipline stages in-progress](/images/chapter4-pipelines/sam-app-pipeline-2.png)
+
+{{% notice note %}}
+You may have noticed our `sam-app-dev` is deployed in a CodePipleine stage named `DeployTest`. The
+`DeployTest` name is hardcoded in the `codepipeline.yaml` file and does not relate in any way to our
+dev application that we named `sam-app-dev`. When you use this template outside this workshow you could
+rename `DeployTest` to anything appropriate.
+{{% /notice %}}
+
+### Inspect the dev/prod stages
+
+Nagivate to the CloudFormation console. After your first Pipeline has finished you will notice two
+new stacks named `sam-app-dev` and `sam-app-prod`. These are the names you provided during the SAM
+Pipelines wizard in the previous step.
+
+CodeBuild created the `sam-app-dev` stack during the `DeployTest` Pipeline step. Similarly,
+CodeBuild created `sam-app-prod` during the `DeployProd` step.
+
+Look at the `Outputs` tab for each of these CloudFormation stacks to see the API endpoints. You can
+use `curl` or other methods to verify the functionality of your two new APIs.
+
+![API endpoints](/images/chapter4-pipelines/sam-app-dev-cfn-outputs.png)
+
+#### You may have noticed that unit tests are not being run in your pipeline. Let's fix that in the next section!