feat: migrate medium posts into here

.github/workflows/website.yml

@@ -82,9 +82,11 @@ jobs:
         run: curl --retry-delay 1 --retry 30 --retry-all-error http://localhost:8080
 
       # medium.com => was being rate limited: HTTP 429
+      # twitter.com => too many redirections
       - run: |
           ./muffet \
             -e 'https://medium.com/runatlantis' \
+            -e 'https://twitter.com/*' \
             -e 'https://github\.com/runatlantis/atlantis/edit/main/.*' \
             -e 'https://github.com/runatlantis/helm-charts#customization' \
             -e 'https://github.com/sethvargo/atlantis-on-gke/blob/master/terraform/tls.tf#L64-L84' \

.markdownlint.yaml

@@ -31,3 +31,8 @@ MD024:
 #
 # https://github.com/DavidAnson/markdownlint/blob/main/doc/md051.md
 MD051: false
+
+# for blog posts
+MD025: false
+MD045: false
+MD001: false

netlify.toml

@@ -21,8 +21,7 @@
   [headers.values]
     X-Frame-Options = "DENY"
     X-XSS-Protection = "1; mode=block"
-    Content-Security-Policy = "default-src 'self'; frame-src 'self' https://app.netlify.com; script-src 'self' https://*.google-analytics.com https://www.googletagmanager.com https://*.algolianet.com https://*.algolia.net 'unsafe-inline'; style-src 'self' https://fonts.googleapis.com https://*.algolianet.com https://*.algolia.net 'unsafe-inline'; img-src 'self' https://*.google-analytics.com data:; font-src 'self' data: https://fonts.googleapis.com https://fonts.gstatic.com; connect-src 'self' https://*.google-analytics.com https://www.googletagmanager.com https://*.algolianet.com https://*.algolia.net"
-    Cache-Control = "public, max-age=86400, must-revalidate"
+    Cache-Control = "public, max-age=86400"
     Strict-Transport-Security = "max-age=86400; includeSubDomains; preload"
     Referrer-Policy = "no-referrer"
     X-Content-Type-Options = "nosniff"

package.json

@@ -5,11 +5,12 @@
     "@playwright/test": "^1.44.0",
     "@types/node": "^20.12.10",
     "@vueuse/core": "^10.9.0",
+    "markdown-it-footnote": "^4.0.0",
+    "markdownlint-cli": "^0.40.0",
     "sass": "^1.77.0",
     "sitemap-ts": "^1.6.1",
     "vitepress": "^1.1.4",
-    "vue": "^3.4.27",
-    "markdownlint-cli": "^0.40.0"
+    "vue": "^3.4.27"
   },
   "scripts": {
     "website:dev": "vitepress dev --host localhost --port 8080 runatlantis.io",

runatlantis.io/.vitepress/config.ts

@@ -1,4 +1,5 @@
 import { generateSitemap as sitemap } from "sitemap-ts"
+import footnote from 'markdown-it-footnote'
 import { defineConfig } from 'vitepress';
 import * as navbars from "./navbars";
 import * as sidebars from "./sidebars";
@@ -114,6 +115,11 @@ export default defineConfig({
         })();`,
         ]
     ],
+    markdown: {
+        config: (md) => {
+          md.use(footnote)
+        }
+    },
     vite: {
         server: {
             fs: {

runatlantis.io/.vitepress/navbars.ts

@@ -3,7 +3,7 @@ const en = [
   { text: "Guide", link: "/guide" },
   { text: "Docs", link: "/docs" },
   { text: "Contributing", link: "/contributing" },
-  { text: "Blog", link: "https://medium.com/runatlantis" },
+  { text: "Blog", link: "/blog" },
 ];
 
 export { en };

runatlantis.io/.vitepress/sidebars.ts

@@ -94,6 +94,56 @@ const en = [
       { text: "Glossary", link: "/contributing/glossary" },
     ]
 
+  },
+  {
+    text: "Blog",
+    link: "/blog",
+    collapsed: false,
+    items: [
+      {
+        text: "2019",
+        collapsed: true,
+        items: [
+          {
+            text: "4 Reasons To Try HashiCorp's (New) Free Terraform Remote State Storage",
+            link: "/blog/2019/4-reasons-to-try-hashicorps-new-free-terraform-remote-state-storage"
+          },
+        ]
+      },
+      {
+        text: "2018",
+        collapsed: true,
+        items: [
+          {
+            text: "I'm Joining HashiCorp!",
+            link: "/blog/2018/joining-hashicorp"
+          },
+          {
+            text: "Putting The Dev Into DevOps: Why Your Developers Should Write Terraform Too",
+            link: "/blog/2018/putting-the-dev-into-devops-why-your-developers-should-write-terraform-too"
+          },
+          {
+            text: "Atlantis 0.4.4 Now Supports Bitbucket",
+            link: "/blog/2018/atlantis-0-4-4-now-supports-bitbucket"
+          },
+          {
+            text: "Terraform And The Dangers Of Applying Locally",
+            link: "/blog/2018/terraform-and-the-dangers-of-applying-locally"
+          },
+          {
+            text: "Hosting Our Static Site over SSL with S3, ACM, CloudFront and Terraform",
+            link: "/blog/2018/hosting-our-static-site-over-ssl-with-s3-acm-cloudfront-and-terraform"
+          },
+        ]
+      },
+      {
+        text: "2017",
+        collapsed: true,
+        items: [
+          { text: "Introducing Atlantis", link: "/blog/2017/introducing-atlantis" },
+        ]
+      },
+    ]
   }
 ]
 

runatlantis.io/blog.md

@@ -0,0 +1,28 @@
+---
+title: Welcome to Our Blog
+aside: false
+---
+
+# Welcome to Our Blog
+
+We are thrilled to have you here! Our blog is a collection of insightful articles, tips, and updates from our team. Whether you're new or have been following us for a while, there's always something new to learn and explore.
+
+### Explore Our Popular Posts
+
+We have a rich history of blog posts dating back to 2017-2019. Here are some of our popular posts:
+
+- [4 Reasons To Try HashiCorp's (New) Free Terraform Remote State Storage](/blog/2019/4-reasons-to-try-hashicorps-new-free-terraform-remote-state-storage)
+- [I'm Joining HashiCorp!](/blog/2018/joining-hashicorp)
+- [Putting The Dev Into DevOps: Why Your Developers Should Write Terraform Too](/blog/2018/putting-the-dev-into-devops-why-your-developers-should-write-terraform-too)
+- [Atlantis 0.4.4 Now Supports Bitbucket](/blog/2018/atlantis-0-4-4-now-supports-bitbucket)
+- [Terraform And The Dangers Of Applying Locally](/blog/2018/terraform-and-the-dangers-of-applying-locally)
+- [Hosting Our Static Site over SSL with S3, ACM, CloudFront and Terraform](/blog/2018/hosting-our-static-site-over-ssl-with-s3-acm-cloudfront-and-terraform)
+- [Introducing Atlantis](/blog/2017/introducing-atlantis)
+
+### Welcoming New Blog Authors
+
+We are excited to welcome new authors to our blog. Our diverse team brings a wealth of knowledge and experience to share with our readers. Stay tuned for fresh perspectives and in-depth articles on the latest trends and technologies.
+
+If you have any questions or topics you would like us to cover, feel free to reach out [on Slack](https://join.slack.com/t/atlantis-community/shared_invite/zt-9xlxtxtc-CUSKB1ATt_sQy6um~LDPNw). We are always looking to engage with our community and provide valuable content.
+
+Happy reading!

runatlantis.io/blog/2017/introducing-atlantis.md

@@ -0,0 +1,113 @@
+---
+title: Introducing Atlantis
+lang: en-US
+---
+
+# Introducing Atlantis
+
+::: info
+This post was originally written on September 11th, 2017
+
+Original post: <https://medium.com/runatlantis/introducing-atlantis-6570d6de7281>
+:::
+
+We're very excited to announce the open source release of Atlantis! Atlantis is a tool for
+collaborating on Terraform that's been in use at Hootsuite for over a year. The core
+functionality of Atlantis enables developers and operators to run `terraform plan` and
+`apply` directly from Terraform pull requests. Atlantis then comments back on the pull
+request with the output of the commands:
+
+![](/blog/intro/intro1.gif)
+
+This is a simple feature, however it has had a massive effect on how our team writes Terraform.
+By bringing a Terraform workflow to pull requests, Atlantis helped our Ops team collaborate
+better on Terraform and also enabled our entire development team to write and execute Terraform safely.
+
+Atlantis was built to solve two problems that arose at Hootsuite as we adopted Terraform:
+
+### 1. Effective Collaboration
+
+What's the best way to collaborate on Terraform in a team setting?
+
+### 2. Developers Writing Terraform
+
+How can we enable our developers to write and apply Terraform safely?
+
+## Effective Collaboration
+
+When writing Terraform, there are a number of workflows you can follow. The simplest workflow is just using `master`:
+
+![](/blog/intro/intro2.webp)
+
+In this workflow, you work on `master` and run `terraform` locally.
+The problem with this workflow is that there is no collaboration or code review.
+So we start to use pull requests:
+
+![](/blog/intro/intro3.webp)
+
+We still run `terraform plan` locally, but once we're satisfied with the changes we create a pull request for review. When the pull request is approved, we run `apply` locally.
+
+This workflow is an improvement, but there are still problems. The first problem is that it's hard to review just the diff on the pull request. To properly review a change, you really need to see the output from `terraform plan`.
+
+![](/blog/intro/intro4.webp)
+
+What looks like a small change...
+
+![](/blog/intro/intro5.webp)
+
+...can have a big plan
+
+The second problem is that now it's easy for `master` to get out of sync with what's actually been applied. This can happen if you merge a pull request without running `apply` or if the `apply` has an error halfway through, you forget to fix it and then you merge to `master`. Now what's in `master` isn't actually what's running on production. At best, this causes confusion the next time someone runs `terraform plan`. At worst, it causes an outage when someone assumes that what's in `master` is actually running, and depends on it.
+
+With the Atlantis workflow, these problems are solved:
+
+![](/blog/intro/intro6.webp)
+
+Now it's easy to review changes because you see the `terraform plan` output on the pull request.
+
+![](/blog/intro/intro7.webp)
+
+Pull requests are easy to review since you can see the plan
+
+It's also easy to ensure that the pull request is `terraform apply`'d before merging to master because you can see the actual `apply` output on the pull request.
+
+![](/blog/intro/intro8.webp)
+
+So, Atlantis makes working on Terraform within an operations team much easier, but how does it help with getting your whole team to write Terraform?
+
+## Developers Writing Terraform
+
+Terraform usually starts out being used by the Ops team. As a result of using Terraform, the Ops team becomes much faster at making infrastructure changes, but the way developers request those changes remains the same: they use a ticketing system or chat to ask operations for help, the request goes into a queue and later Ops responds that the task is complete.
+
+Soon however, the Ops team starts to realize that it's possible for developers to make some of these Terraform changes themselves! There are some problems that arise though:
+
+- Developers don't have the credentials to actually run Terraform commands
+- If you give them credentials, it's hard to review what is actually being applied
+
+With Atlantis, these problems are solved. All `terraform plan` and `apply` commands are run from the pull request. This means developers don't need to have any credentials to run Terraform locally. Of course, this can be dangerous: how can you ensure developers (who might be new to Terraform) aren't applying things they shouldn't? The answer is code reviews and approvals.
+
+Since Atlantis comments back with the `plan` output directly on the pull request, it's easy for an operations engineer to review exactly what changes will be applied. And Atlantis can run in `require-approval` mode, that will require a GitHub pull request approval before allowing `apply` to be run:
+
+![](/blog/intro/intro9.webp)
+
+With Atlantis, developers are able to write and apply Terraform safely. They submit pull requests, can run `atlantis plan` until their change looks good and then get approval from Ops to `apply`.
+
+Since the introduction of Atlantis at Hootsuite, we've had **78** contributors to our Terraform repositories, **58** of whom are developers (**75%**).
+
+## Where we are now
+
+Since the introduction of Atlantis at Hootsuite we've grown to 144 Terraform repositories [^1] that manage thousands of Amazon resources. Atlantis is used for every single Terraform change throughout our organization.
+
+## Getting started with Atlantis
+
+If you'd like to try out Atlantis for your team you can download the latest release from <https://github.com/runatlantis/atlantis/releases>. If you run `atlantis testdrive` you can get started in less than 5 minutes. To read more about Atlantis go to <https://www.runatlantis.io/>.
+
+Check out our video for more information:
+
+<iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FTmIPWda0IKg%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DTmIPWda0IKg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FTmIPWda0IKg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" allowfullscreen="" frameborder="0" height="480" width="640" title="Atlantis Walkthrough" class="fr n gh dv bg" scrolling="no"></iframe>
+
+[^1]: We split our Terraform up into multiple states, each with its own repository (see [1], [2], [3]).
+
+[1]: https://blog.gruntwork.io/how-to-manage-terraform-state-28f5697e68fa
+[2]: https://charity.wtf/2016/03/30/terraform-vpc-and-why-you-want-a-tfstate-file-per-env/
+[3]: https://www.nclouds.com/blog/terraform-multi-state-management/