Wilson Mar bio photo

Wilson Mar


Calendar YouTube Github


Deploy and control AWS, Azure, GCP, K8S, Serverless by coding JavaScript, TypeScript, Go, Python, etc.

US (English)   Norsk (Norwegian)   Español (Spanish)   Français (French)   Deutsch (German)   Italiano   Português   Estonian   اَلْعَرَبِيَّةُ (Egypt Arabic)   Napali   中文 (简体) Chinese (Simplified)   日本語 Japanese   한국어 Korean


This is a hands-on introduction carefully sequenced to make complex material easier to understand quickly. This is not a “demo”, but an immersive step-by-step “deep dive” tutorial aimed to make you productive, without sales generalizations. “PROTIP” in the text highlight useful tools and insightful commentary based on experience by the author.

NOTE: Content here are my personal opinions, and not intended to represent any employer (past or present). “PROTIP:” here highlight information I haven’t seen elsewhere on the internet because it is hard-won, little-know but significant facts based on my personal research and experience.

One program that does it all

What happens when a program that references services in the cloud (such as Azure Redis Cache) cannot find that service? To remediate, the developer needs to switch to a whole other set of code (Terraform) and pipelines to manage provisioning of resources necessary for the program to run.

Wouldn’t it be convenient if references to cloud resources “self heal” by creating the resources needed right there and then, rather than bombing out? Sure, the program may have to wait, and it would be faster if the resource are setup ahead of time. But self-provisioning would be convenient during development work. In production, that would raise resilience and reliability.

An example is looking into Dynamic Programming strategies, which reduces processing time by “momoization” so programs are referencing the results of previous processing in an array in memory rather than recalculating everything (as in recursively). Taking that further, how about having that array in Redis available to many programs running in different locations (as in HA). Think of an army creating more Fibonicci numbers rather than each starting from 0 ;) When the first program runs, if the service is not there, it would be created automatically (at run-time).

That’s the wonderful prospect of application code having a connection to resource provisioning. Such an approach would likely not mean application code also containing all the provisioning code. Perhaps a Service Mesh (Istio) type of approach already available for Kubernetes, such as Cisco Portshift?

One programming language to rule them all

The declarative HCL (JSON) syntax Terraform uses is concise because its users don’t have to code logic to determine whether a resource has already been created before trying to create it. And Terraform automatically provisions in the correct order of dependencies.

But some feel that is actually limiting because it doesn’t have the looping and other features of a programmatic approach like writing Python, JavaScript, or Go code, which application developers are familiar using.

TWEET: “What if you used the same language and tools you use to define your app to define your infrastructure?”

Pulumi’s technologies enable developers to manage resources (Kubernetes, Serverless Lambdas/Functions, etc.) within multiple clouds by coding in a general programming language referencing Pulumi’s SDK libraries rather than editing declarative text files (in YAML of AWS Cloud Formation, HCL of Terraform).

BTW the company/product name “Pulumi” is the Hawaiian word for “broom”, adopted as a homophone (mispronunciation) of Chris Brumme’s name, a friend and mentor of CEO Joe Duffy.

Forbes article Oct 16, 2018

Sample Pulumi JavaScript

As an example, here’s JavaScript for Pulumi to create a new bucket in AWS S3:

   var aws = require("@pulumi/aws");
   const bucket = new aws.s3.Bucket("my-bucket");
  • When inside a .js file, “my-bucket” can be substituted with a variable.
  • The lines can be reused by being within a loop or placed in functions, and classes.
  • A single source code file can operate (transfer data) across several clouds (AWS, Azure, GCP, OpenStack, VMWare vSphere, etc.).
  • Use of general programming languages enable incorporation of code such as sending out emails, SMS texts, Slack notifications, etc.
  • Enforced error handling, compiler errors on invalid syntax, stack track debugging with line numbers.

The sample code above is specific to a particular cloud platform (aws).

The above is akin to calls to the AWS Boto3 Python library, but Pulumi enables more languages and cloud platforms and services in those clouds (such as Kubernetes and serverless lambdas/functions).

Kris Nova blogged about transitioning from the YAML in kops cluster tool: “We replaced 1,000 lines of YAML with 10 Go structs and people started contributing again”.


Pulumi works kinda like Microsoft’s .NET CLR (Common Language Runtime) which compiles several languages into a common set of instructions at the machine level. In fact, Pulumi’s engine was created by some of the people who worked on Microsoft’s CLR (Matt Ellis @ellismg, Pat Gavlin, etc.).

Thus, Pulumi is also working on building on top of the “@pulumi/aws” library to combine infrastructure definitions and application code in the same program source file using, initially, their @pulumi/cloud-aws API.

multi-cloud coding

Pulumi is also working on “multi-cloud” coding that can be applied to several cloud platforms: the Pulumi Cloud Framework at https://github.com/pulumi/pulumi-cloud with higher-level “abstractions” such as

[Service], [Table], [Topic], and [API]

The plan is to offer an implementation of this on all major clouds rather than just aws currently. See Pulumi’s full Roadmap.

See https://pulumi.io/quickstart/cloudfx/index.html and [37:36] video

Infrastructure as Code (IaC)

https://github.com/pulumi/examples presents sample code for various clouds. The use cases have this naming convention:

cloud provider (platform or service) - language - use case

Cloud platforms are:

  • aws (Amazon Web Services)
  • azure (from Microsoft) - https://pulumi.io/reference/cd-azure-devops.html
  • gcp (Google Cloud Platform)
  • OpenStack and VMWare vSphere are coming

The ability to control IBM, Alibaba, Rackspace, and other clouds not yet defined can be converted from Terraform HCL files to Typescript programming code using the tf2pulumi utility (written in Golang).

  • https://github.com/pulumi/pulumi-terraform-template
  • https://github.com/pulumi/pulumi-alicloud by Pat Gavlin

The Pulumi Terraform Bridge and examples of its output is at https://github.com/pulumi/tf12-vs-pulumi

Cloud services:

  • kubernetes
  • multicloud
  • twilio (to send SMS texts, phone messages, etc.) https://github.com/pulumi/examples/blob/master/twilio-ts-component
  • https://github.com/pulumi/pulumi-openfaas

Pulumi provides an SDK of classes for programming clouds at repo
https://pulumi.io/reference/pkg/index.html (which is generated by Jekyll from the https://github.com/pulumi/docs repo).


NOTE: AWS is creating their own Cloud Develop Kit” (CDK).

Hashicorp is also creating their own.



Languages supported are

  • go for GoLang (as in aws-go-s3-folder)
  • js for JavaScript
  • ts for TypeScript (a wrapper over JavaScript)
  • py for Python 3.6+ (https://pulumi.io/reference/python.html) https://pypi.org/project/pulumi/

Pulumi has Terraform plug-ins:

Dependencies & State like Terraform

The Pulumi engine itself is written in GoLang*

Pulumi determines the sequence which infrastucture components need to be created by compiling programming code languages. Internally, Pulumi resolves dependencies by building a data stucture (a Directed Acyclic Graph like Git does) needed to build the desired state requested from programs.

Pulumi stores its own copy of the current state of each stack in transactional snapshots called checkpoints at various points in time. This works like Puppet which makes a “diff” of the goal state and compares it versus current state to identify drift or what needs to be updated.

This is similar to what Hashicorp’s Terraform does under the covers.

QUESTION: Provide “production-ready” code like Gruntwork does for Terraform users?

BTW gRPC utilizes protocol buffers to communicate the interface of the services and then has a compiler to generate source code in one of a variety of supported languages. https://github.com/pulumi/pulumi/tree/master/sdk/proto https://grpc.io/docs/tutorials/basic/node.html Protocol buffers (protobuf) https://forestgiant.com/articles/protocol-buffers/

#NoYAML for True DevOps + SRE

Pulumi’s approach solves a fundamental problem for DevSecOps.

PROTIP: Coding YAML to configure AWS CloudFormation or Terraform declarative DSL, with their thousands of cryptic settings, is a complexity which requires dedicated specialists that are in short supply (thus difficult to find). Because of their specialization, some employers isolate experts to work separately from development people who have to literally get in line to talk to the experts.

Such separation does not satisfy the need for increasing delivery speed, namely:

“Share ownership with developers by using the same tools and techniques across the stack”*

“By making it trivial for developers and testers to spin up and tear down lots of stacks, Pulumi reduces the friction and thus enhances the speed to test out each Pull Request (individual feature) or entire tiers of technology.”

https://noyaml.com/ from code at https://github.com/ghuntley/noyaml

  • https://arp242.net/weblog/yaml_probably_not_so_great_after_all.html

  • https://www.pulumi.com/docs/intro/concepts/

Pulumi Website

  1. Open an internet browser (Google Chrome is preferred).

  2. Use a browser profile you use to login to the GitHub account you’ll use with Pulumi at:


    This establishes credentials in the browser for use by Pulumi Cloud in the next steps.

  3. In the same browser, paste this URL to enter the Pulumi Cloud Console :


    Pulumi Organization

  4. Click “Create organization” to claim your name

    How Pulumi makes money: Pricing

  5. Note the trial expiration date (one month).

    Code for the pulumi CLI is open-sourced at https://github.com/pulumi/pulumi and the Pulumi company has joined the CNCF (Cloud Native Computing Foundation).

    BTW, Pulumi is funded by Madrona Venture Group, who also funded Lyft, Heptio, Tigera.

    Pulumi works on a Freemium business model, with a free tier for a single “stack” without enterprise scale and security features.

    Each Pulumi “stack” is an isolated instance of a particular environment such as dev, qa, staging, prod-west, prod-east, etc. See https://pulumi.io/reference/stack.html

    You are charged for the number of stacks. See https://www.pulumi.com/pricing/

    Pulumi also makes money from offering team, enterprise features, and on-premise self-hosting.

    See https://github.com/wilsonmar/docs-2/blob/master/reference/service/editions.md

  6. To use Pulumi’s Team features (for $600/year after a 14-day free trial), define a Pulumi organization at:



  7. Get an access token from https://app.pulumi.com/account/tokens


PROTIP: The brevity of Pulumi’s code makes it ideal for the next advancement in technical tutorials. The current approach on ACloud.guru, Pluralsight, Lynda.com, etc. is that you first view videos to learn concepts, then manually click through GUI. However, in this tutorial, you first run a script that does everything, then you get explanation of the automated steps as you customize the script for your own needs.

MEH: Pulumi’s instructions assume that readers manually enter pulumi cli commands. Sorry but that’s slow and error-prone.

PROTIP: So you can get to work quicker (without a background in other tools), I built a Bash script to automatically install all the pre-requisite utilities and files to enable Pulumi’s multi-cloud and multi-language capabilities.


The shell script above installs packages in this specific sequence: xcode-cli, homebrew, VSCode, git, Python3 > aws & azure-cli, Node.js, Go, Docker, Pulumi CLI.

Included in the bottom of the script is a sample use of a simple Pulumi deployment before cleaning up so charges do not linger.

The script is designed to be idempotent in that it can be rerun repeatedly. For this reason, the script deletes what is left over from a previous run. The script also has a flag which defaults to deleting what was created at the end of the script, so billing is minimized.

PROTIP: I recommend that you edit and add to the bottom of installation scripts I’ve provided. It only takes a few seconds to run. This ensure that you have the environment necessary in case of configuration changes and upgrades. And if you run into issues, the install portion of the script outputs version numbers to inform debugging efforts.

Every time it runs, it clones or pulls (updates) repos into its local .pulumi folder:

  • https://github.com/pulumi/examples
  • https://github.com/pulumi/templates

Pulumi CLI Install

Pulumi CLI installer for macOS and Windows package managers.

For macOS:

  1. Pulumi provides its own Bash shell script to install the Pulumi CLI program. This has the advantage of using the same command for first-time install as well as update:

    curl -fsSL https://get.pulumi.com | sh
    • It extracts to path $HOME/.pulumi/bin such as /Users/wilsonmar/.pulumi/bin.
    • It adds $HOME/.pulumi/bin to $PATH in /Users/wilsonmar/.bash_profile

  2. Use Homebrew for easy upgrades and because it does not require changes to my .bash_profile since it uses the same mechanism as other packages:

    brew install pulumi

    In the response, note that the download is for a specific macOS version:

    Date Version # files Size
    2021-09-20 /usr/local/Cellar/pulumi/3.12.1 18 files 134.5MB
    2021-04-26 /usr/local/Cellar/pulumi/3.1.0 18 files 134.0MB
    2018-12-10 /usr/local/Cellar/pulumi/0.16.7 13 files 80.9MB
    2018-12-05 /usr/local/Cellar/pulumi/0.16.6 13 files 80.9MB

    NOTE: In the Info/Caveats: The installer adds code completion hints for Bash, ZSH.

    Bash completion has been installed to:
    zsh completions have been installed to:

    ??? Either way, VSCode autocomplete are installed for 500+ AWS APIs are installed with autocomplete for the JavaScript let commands which define properties.

  3. Verify the install

    pulumi version

    The response should show the same version as in the output message:

  4. Install bash completion:

    brew install bash-completion

    See https://pulumi.io/reference/commands.html#command-line-completion

    VSCode autocomplete for 500+ AWS APIs?

  5. Navigate/create to a project folder.

  6. To install the core API package, use either npm:

    npm install @pulumi/cloud

    Alternately, if you use yarn:

    yarn add @pulumi/cloud

Pulumi CLI commands

  1. View the parameters for the “pulumi new” command:

    Pulumi - Modern Infrastructure as Code
    To begin working with Pulumi, run the `pulumi new` command:
     $ pulumi new
    This will prompt you to create a new project for your cloud and language of choice.
    The most common commands from there are:
     - pulumi up       : Deploy code and/or resource changes
     - pulumi stack    : Manage instances of your project
     - pulumi config   : Alter your stack's configuration or secrets
     - pulumi destroy  : Tear down your stack's resources entirely
    For more information, please visit the project page: https://www.pulumi.com/docs/
      pulumi [command]
    Available Commands:
      cancel         Cancel a stack's currently running update, if any
      config         Manage configuration
      console        Opens the current stack in the Pulumi Console
      destroy        Destroy an existing stack and its resources
      help           Help about any command
      import         Import resources into an existing stack
      login          Log in to the Pulumi service
      logout         Log out of the Pulumi service
      logs           [PREVIEW] Show aggregated resource logs for a stack
      new            Create a new Pulumi project
      plugin         Manage language and resource provider plugins
      policy         Manage resource policies
      preview        Show a preview of updates to a stack's resources
      refresh        Refresh the resources in a stack
      stack          Manage stacks
      state          Edit the current stack's state
      up             Create or update the resources in a stack
      version        Print Pulumi's version number
      watch          [PREVIEW] Continuously update the resources in a stack
      whoami         Display the current logged-in user
       --color string                 Colorize output. Choices are: always, never, raw, auto (default "auto")
      -C, --cwd string                   Run pulumi as if it had been started in another directory
       --disable-integrity-checking   Disable integrity checking of checkpoint files
      -e, --emoji                        Enable emojis in the output (default true)
      -h, --help                         help for pulumi
       --logflow                      Flow log settings to child processes (like plugins)
       --logtostderr                  Log to stderr instead of to files
       --non-interactive              Disable interactive mode for all commands
       --profiling string             Emit CPU and memory profiles and an execution trace to '[filename].[pid].{cpu,mem,trace}', respectively
       --tracing file:                Emit tracing to the specified endpoint. Use the file: scheme to write tracing data to a local file
      -v, --verbose int                  Enable verbose logging (e.g., v=3); anything >3 is very verbose
    Use "pulumi [command] --help" for more information about a command.
  2. https://pulumi.io/tour/basics-projects.html (based on https://github.com/wilsonmar/docs-2/tree/master/tour)

    • Programs
    • Creating a project
    • Deploying code
    • Previewing
    • Spinning up
    • Performing updates
    • Destroying

    VIDEO: Ep 002: How Pulumi Works [40:41] using AWS Fargate (not lower-level ECS)

  3. Make a Git-backed folder to contain your new Pulumi project repo.

  4. View the parameters for the “pulumi new” command:

    pulumi new --help
      Global flags:
       --color string                 Colorize output. Choices are: always, never, raw, auto (default "auto")
      -C, --cwd string                   Run pulumi as if it had been started in another directory
       --disable-integrity-checking   Disable integrity checking of checkpoint files
      -e, --emoji                        Enable emojis in the output (default true)
      -h, --help                         help for pulumi
       --logflow                      Flow log settings to child processes (like plugins)
       --logtostderr                  Log to stderr instead of to files
       --non-interactive              Disable interactive mode for all commands
       --profiling string             Emit CPU and memory profiles and an execution trace to '[filename].[pid].{cpu,mem,trace}', respectively
       --tracing string               Emit tracing to a Zipkin-compatible tracing endpoint
      -v, --verbose int                  Enable verbose logging (e.g., v=3); anything >3 is very verbose

    PROTIP: There is a list of templates available from https://github.com/pulumi/templates at the bottom of the response:

       aws-go                   A minimal AWS Go Pulumi program
      aws-javascript           A minimal AWS JavaScript Pulumi program
      aws-python               A minimal AWS Python Pulumi program
      aws-typescript           A minimal AWS TypeScript Pulumi program
      azure-go                 A minimal Azure Go Pulumi program
      azure-javascript         A minimal Azure JavaScript Pulumi program
      azure-python             A minimal Azure Python Pulumi program
      azure-typescript         A minimal Azure TypeScript Pulumi program
      gcp-go                   A minimal Google Cloud Go Pulumi program
      gcp-javascript           A minimal Google Cloud JavaScript Pulumi program
      gcp-python               A minimal Google Cloud Python Pulumi program
      gcp-typescript           A minimal Google Cloud TypeScript Pulumi program
      go                       A minimal Go Pulumi program
      hello-aws-javascript     A simple AWS serverless JavaScript Pulumi program
      javascript               A minimal JavaScript Pulumi program
      kubernetes-javascript    A minimal Kubernetes JavaScript Pulumi program
      kubernetes-typescript    A minimal Kubernetes TypeScript Pulumi program
      openstack-go             A minimal OpenStack Go Pulumi program
      openstack-javascript     A minimal OpenStack JavaScript Pulumi program
      openstack-python         A minimal OpenStack Python Pulumi program
      openstack-typescript     A minimal OpenStack TypeScript Pulumi program
      python                   A minimal Python Pulumi program
      typescript               A minimal TypeScript Pulumi program

    A new command crates in the present working directory a Pulumi.yaml file containing some minimal metadata about your project (including a name and description which you may wish to change).

  5. To create a new project by specifying a template name:

    pulumi new template-name

    NOTE: pulumi new has these parameters:

      -c, --config stringArray   Config to save
      -d, --description string   The project description; if not specified, a prompt will request it
       --dir string           The location to place the generated project; if not specified, the current directory is used
      -f, --force                Forces content to be generated even if it would change existing files
      -g, --generate-only        Generate the project only; do not create a stack, save config, or install dependencies
      -h, --help                 help for new
      -n, --name string          The project name; if not specified, a prompt will request it
      -o, --offline              Use locally cached templates without making any network requests
      -s, --stack string         The stack name; either an existing stack or stack to create; if not specified, a prompt will request it
       --suppress-outputs     Suppress display of stack outputs (in case they contain sensitive values)
      -y, --yes                  Skip prompts and proceed with default values

    If you issue “pulumi new” before login:

    warning: A new version of Pulumi is available. To upgrade from version '0.16.6' to '0.16.7', visit https://pulumi.io/install for manual instructions and release notes.
    Manage your Pulumi stacks by logging in.
    Run `pulumi login --help` for alternative login options.
    Enter your access token from https://app.pulumi.com/account
     or hit  to log in using your browser            : 
  6. Configuration by Enterprise users can encrypt configuration in your stack, you’ll need to re-run

    pulumi config set --secret key value 

    This is because pulumi.com uses a different key to encrypt your secrets than the local endpoint.

    To create a stack in a different Pulumi organization, prefix the stack’s name with the organization’s login:

    pulumi stack init acme-corp/widget-server
  7. To Deploy code and/or resource changes:

    pulumi up
  8. Install the az cli

  9. To preview and deploy changes to your program and/or infrastructure

    https://github.com/pulumi/apps ???

  10. To configure variables such as keys, regions, etc.

    pulumi config
  11. Log into the Pulumi service then display current logged in user:

    pulumi login

    This is equivalent to manually logging into the https://app.pulumi.com Pulumi Cloud Console using your GitHub or GitLab credentials.

  12. To verify:

    pulumi whoami
  13. Manage language and resource provider plugins

    pulumi plugin
  14. To list key-value pairs managed by pulumi, such as aws:region us-west-2

    pulumi stack ls
  15. To manage stacks (at least one is required to perform an update):

    pulumi stack select name
    pulumi stack output

    lists content of “export let publicIp = server.publicIp;”

  16. To preview your changes explicitly before deploying

    pulumi preview

    [9:09] Like Terraform, internally, Pulumi builds a graph that represents the desired goal state, then diff the current state to create a plan.

  17. To build using yarn (instead of Maven or Ant):

    yarn build
  18. Refresh the resources in a stack:

    pulumi refresh
  19. Edit the current stack’s state:

    pulumi state
  20. Update Pulumi CLI:

    pulumi update
  21. Show aggregated logs for a stack:

    pulumi logs

    Destroy and Logout

    While you are testing pulumi commands:

  22. Destroy your program and its infrastructure when you’re done

    pulumi destroy
  23. Log out of the Pulumi service

    pulumi logout

BTW, functional in the CLI can be accessed in code:

What Pulumi doesn’t do

Unlike Terraform, Pulumi has no equivalent of taint/untaint. To remediate failed updates, you need to edit the state file manually.

Integrations to CI/CD




Pulumi has automated integrations for CI/CD (Continuous Integrations & Deployment):

https://pulumi.io/reference/cd-github-actions.html makes use of https://developer.github.com/actions/ beta

To update your Pulumi stack on-demand from AWS CodeBuild and other AWS Code Services products, configure your CloudBuild project.


TravisCI can bet set to add a comment to specific GitHub repos about the result of pull requests by installing https://github.com/apps/pulumi, as described at here. Access to source code is not needed for this.

To avoid multiple commits being merged into the master branch at the same time, To avoid conflicting resource updates or corrupting resource state. https://github.com/pulumi/travisqueue limits build concurrency on a per-branch basis. This allows you to limit the number of concurrent builds for any branches that are configured to perform a Pulumi update. So Travis will only have one build for the master branch at a time, but could be running any number of conrrent builds for other branches. .travis.yml file ???


Contribution to open source

Pulumi created and open-sourced a tool: Kubespy at https://github.com/pulumi/kubespy

Pulumi Jobs

  • https://www.indeed.com/q-Pulumi-jobs.html
  • https://www.indeed.com/jobs?q=pulumi&l=

  • https://www.upwork.com/search/profiles/?q=pulumi&user_pref=2

Pulumi as a company

Pulumi US offices are at 520 E. Denny Way, Seattle, WA 98122

  • Join pulumi-community.slack.com: https://slack.pulumi.com/

  • https://www.glassdoor.com/Reviews/Pulumi-Reviews-E3245815.htm
  • https://stackoverflow.com/search?q=%23pulumi

  • @PulumiCorp joined Twitter March 2017.
  • https://www.linkedin.com/company/pulumi

  • tour.
  • Pulumi’s QuickStart
  • Delivering Cloud Native Infrastructure as Code, a Pulumi white paper

  • June 18, 2018 - [[CMO Joe Duffy blogs “Hello Pulumi” announcing the platform]]cite web|url=http://joeduffyblog.com/2018/06/18/hello-pulumi/|title=Hello Pulumi|publisher=joeDuffyBlog.com

  • October 22, 2018 - [[Pulumi raises $15M for its infrastructure as code platform]]cite web|url=https://techcrunch.com/2018/10/22/pulumi-raises-15m-for-its-infrastructure-as-code-platform/|title=Pulumi raises $15M for its infrastructure as code platform|publisher=TechCrunch.com

  • https://techcrunch.com/2018/06/18/pulumi-wants-to-let-you-manage-your-infrastructure-with-code/

Rock stars

https://www.youtube.com/channel/UC2Dhyn4Ev52YSbcpfnfP0Mw YouTube channel

https://www.youtube.com/watch?v=YMAe59BYzm4 Ep 002: How Pulumi Works [40:41]

http://joeduffyblog.com/ Joe Duffy is Founder/CEO https://github.com/joeduffy

https://www.youtube.com/watch?v=DM8Wd4f1MNA Twitch stream Ep 000: Pulumi Prolog Jun 5, 2018 Luke Hoban, CTO https://www.linkedin.com/in/lukejhoban/ from Amazon & Microsoft

Marc Holmes CMO https://www.linkedin.com/in/marcholmes/ from Chef and Docker


https://hire.withgoogle.com/public/jobs/pulumicom/view/P_AAAAAAFAAC1NXwlGmpMEPP Developer Advocate job

Sean Gillespie https://twitter.com/swgillespie @swgillespie

davidk01 David karapetyan https://dev.to/davidk01/bootstrapping-a-consul-cluster-with-pulumi-35d4

Alex Clemmer wrote the Kubernetes provider https://pulumi-community.slack.com/team/UBAJ7TD53

https://www.cncf.io/ck Certified Kubernetes Conformance tests




More on DevOps

This is one of a series on DevOps:

  1. DevOps_2.0
  2. ci-cd (Continuous Integration and Continuous Delivery)
  3. User Stories for DevOps
  4. Enterprise Software)

  5. Git and GitHub vs File Archival
  6. Git Commands and Statuses
  7. Git Commit, Tag, Push
  8. Git Utilities
  9. Data Security GitHub
  10. GitHub API
  11. TFS vs. GitHub

  12. Choices for DevOps Technologies
  13. Pulumi Infrastructure as Code (IaC)
  14. Java DevOps Workflow
  15. Okta for SSO & MFA

  16. AWS DevOps (CodeCommit, CodePipeline, CodeDeploy)
  17. AWS server deployment options
  18. AWS Load Balancers

  19. Cloud services comparisons (across vendors)
  20. Cloud regions (across vendors)
  21. AWS Virtual Private Cloud

  22. Azure Cloud Onramp (Subscriptions, Portal GUI, CLI)
  23. Azure Certifications
  24. Azure Cloud

  25. Azure Cloud Powershell
  26. Bash Windows using Microsoft’s WSL (Windows Subsystem for Linux)
  27. Azure KSQL (Kusto Query Language) for Azure Monitor, etc.

  28. Azure Networking
  29. Azure Storage
  30. Azure Compute
  31. Azure Monitoring

  32. Digital Ocean
  33. Cloud Foundry

  34. Packer automation to build Vagrant images
  35. Terraform multi-cloud provisioning automation
  36. Hashicorp Vault and Consul to generate and hold secrets

  37. Powershell Ecosystem
  38. Powershell on MacOS
  39. Powershell Desired System Configuration

  40. Jenkins Server Setup
  41. Jenkins Plug-ins
  42. Jenkins Freestyle jobs
  43. Jenkins2 Pipeline jobs using Groovy code in Jenkinsfile

  44. Docker (Glossary, Ecosystem, Certification)
  45. Make Makefile for Docker
  46. Docker Setup and run Bash shell script
  47. Bash coding
  48. Docker Setup
  49. Dockerize apps
  50. Docker Registry

  51. Maven on MacOSX

  52. Ansible
  53. Kubernetes Operators
  54. OPA (Open Policy Agent) in Rego language

  55. MySQL Setup

  56. Threat Modeling
  57. SonarQube & SonarSource static code scan

  58. API Management Microsoft
  59. API Management Amazon

  60. Scenarios for load
  61. Chaos Engineering

More about Azure

This is one of a series about Azure cloud:

More on Amazon

This is one of a series on Amazon:

More about Python

This is one of a series about Python:

  1. Python install on MacOS
  2. Python install on MacOS using Pyenv
  3. Python install on Raspberry Pi for IoT

  4. Python tutorials
  5. Python Examples
  6. Python coding notes
  7. Pulumi controls cloud using Python, etc.
  8. Jupyter Notebooks provide commentary to Python

  9. Python certifications

  10. Test Python using Pytest BDD Selenium framework
  11. Test Python using Robot testing framework
  12. Testing AI uses Python code

  13. Microsoft Azure Machine Learning makes use of Python

  14. Python REST API programming using the Flask library
  15. Python coding for AWS Lambda Serverless programming
  16. Streamlit visualization framework powered by Python
  17. Web scraping using Scrapy, powered by Python
  18. Neo4j graph databases accessed from Python