September 2020 Summaries

The text explores anti-patterns in container and Kubernetes environments, emphasizing the pitfalls and solutions associated with hardcoding configurations, handling dependencies, and setting resource limits. It highlights the use of ConfigMaps in Kubernetes to decouple configuration from applications, allowing for dynamic updates without rebuilding images. The importance of managing dependencies through patterns such as retries and resource inputs and outputs is discussed, with Pulumi's infrastructure as code solution facilitating this by understanding resource dependencies. The text also advises against deploying naked Pods and mixing production with non-production workloads in the same cluster, recommending deployment strategies like using ReplicaSets and setting specific image tags to ensure stability. Pulumi's policy as code, like Crossguard, helps enforce best practices such as prohibiting naked Pods and ensuring resources are tagged correctly for production. Automating these practices through infrastructure as code provides granular control over resources, preventing common anti-patterns and allowing efficient, concurrent service deployment.

Fernando Carletti, a Lead DevOps Engineer, discusses the use of the Pulumi Auth0 provider to manage authentication resources at Credijusto, emphasizing its ability to streamline authentication processes across applications and APIs. The article outlines the process of setting up a new Pulumi project with Auth0, detailing the configuration of backend and single-page applications (SPA) and integrating them with GitHub for OAuth authentication. Carletti explains how to establish Auth0 resources, configure credentials, and set up tenants and applications, highlighting the importance of using distinct credentials for production environments. Additionally, the piece illustrates how to create social connections, such as with GitHub, to enable authentication capabilities for the applications, while also noting that Pulumi facilitates the management and replication of Auth0 configurations across different environments.

Pulumi has launched the beta version of its next-generation Azure provider, the azure-nextgen, which aims to deliver comprehensive support for Microsoft Azure's API surface by working directly with the Azure Resource Manager (ARM) platform. This new provider enhances quality and fidelity with Azure by supporting 890 resource types at launch, nearly doubling the previous number, and ensuring full API coverage across Azure services. It automatically updates via an automated pipeline that incorporates changes from Azure API specifications, ensuring that SDKs remain current without manual intervention. The azure-nextgen provider is available in preview for all Pulumi languages and integrates seamlessly with Azure's ecosystem, offering tools to convert ARM templates to Pulumi programs and allowing existing Azure resources to be managed with the new provider. While the current Pulumi Azure provider will continue to receive updates, the new provider offers a more robust and reliable solution for managing cloud infrastructure, with new projects defaulting to azure-nextgen upon its general availability.

Zephyr Zhou, a senior Computer Science student at the University of Washington, shares the transformative experience of interning at Pulumi during the COVID-19 pandemic, highlighting significant personal and professional growth. Despite initial apprehensions due to limited prior exposure to cloud technology and programming, Zhou embraced the challenges of working remotely at a startup, which facilitated a supportive environment for learning and collaboration. Through the internship, Zhou gained confidence and developed essential skills in cloud technology, Continuous Integration/Continuous Delivery, and modern front-end development, while successfully leading a content management system project for Pulumi’s website. Zhou reflects on the importance of time management and communication in project development, expressing gratitude to mentors and colleagues for their guidance and support, which played a crucial role in building confidence and preparing for a future career in the technology industry.

The blog post explores the process of converting a PERN stack application, which uses PostgreSQL, to a MERN stack by replacing PostgreSQL with MongoDB within a Kubernetes environment. This transition, facilitated by Pulumi and Kubernetes, highlights the modularity and ease of altering components in containerized applications. The primary focus of the conversion is on the database component due to the structural differences between PostgreSQL's relational model and MongoDB's key-value storage system. Despite the database switch, most of the existing code from the PERN application can be reused with minimal adjustments, primarily involving MongoDB-specific changes in the database, server, and client components. The post provides a detailed step-by-step guide, including commands and code snippets, to clone the existing application, configure the new MongoDB setup, and implement the necessary changes to integrate the MongoDB database into the Kubernetes deployment. This showcases the adaptability of containerized applications, emphasizing how design changes can be efficiently managed without extensive code rewriting, ultimately demonstrating the flexibility of modern development practices.

Albert, a computer science student at the University of Washington, reflects on his internship experience at Pulumi, a company specializing in modern infrastructure as code. He first encountered Pulumi at a career fair and was intrigued by its approach to cloud infrastructure management using familiar programming languages. Despite initial concerns about the internship's continuity due to the COVID-19 pandemic, Pulumi transitioned to a virtual setup, allowing Albert to work remotely on his project, crd2pulumi—a CLI tool for generating typed Kubernetes CustomResources. Throughout the summer, Albert gained valuable insights into real-world software engineering, overcoming challenges related to debugging and code integration while appreciating the balance between guidance and autonomy provided by the company. Although the remote format limited social interaction, Albert valued the flexibility it offered and the exposure to new technologies and practices. He concludes with a newfound awareness of the vastness of the cloud ecosystem and gratitude for the opportunity to learn and contribute at Pulumi.

Sashu Shankar, a second-year computer science student at the University of Washington, shares their experience as a remote intern at Pulumi, highlighting the challenges of onboarding during a chaotic time and the supportive nature of the team. Despite initial nerves and questions about the company's remote culture, Sashu found the team welcoming, which made the experience more manageable. The internship provided valuable learning experiences, including converting Pulumi deployment examples into various programming languages, developing a CLI tool and open-source library to simplify Kubernetes to Pulumi transitions, and creating a UI interface to enhance user interaction. Sashu appreciated the mentorship and camaraderie at Pulumi, which contributed to a transformative experience, and expressed gratitude to colleagues and mentors for their support and guidance. Through this internship, Sashu gained a deeper understanding of the cloud as a tool for building visions and dreams, with Pulumi as a facilitator in that journey.

The blog post explores the process and benefits of deploying a PERN (PostgreSQL, Express, React, Node.js) application to Amazon EKS using Kubernetes and Pulumi. It highlights Kubernetes' advantages, such as minimizing downtime, facilitating updates, and enabling scalable infrastructure across multiple cloud providers like AWS, Azure, and GCP. The document provides a step-by-step guide on setting up the application, starting from cloning the Typescript PERN example, configuring necessary variables, and integrating Pulumi for infrastructure management. The process involves the creation of a PostgreSQL Docker container, setting up Kubernetes deployments and services for the database, server, and client components, and utilizing AWS Elastic Kubernetes Service to manage the application's scalability and resilience. The post concludes with a preview of an upcoming exploration of applications using the MERN stack, emphasizing the scalability and efficiency of containerized services for growing applications.

The text outlines the deployment of a CMS application on AWS using ECS Fargate, which required an external OAuth server due to the inability to use Netlify's Identity Service. Utilizing a polyglot approach, the OAuth server is implemented in Go, while the infrastructure is managed with a Typescript Pulumi project. The deployment process includes setting up environment variables for authentication, configuring OAuth server callbacks for repository providers like GitHub, GitLab, and Bitbucket, and establishing secure communication using HTTPS through an Application Load Balancer. The text also describes the creation of a certificate for the OAuth server, the use of Pulumi's random package to generate session secrets, and the automation of the build process using GitHub Actions. Finally, it emphasizes updating the CMS configuration file to integrate the CMS and OAuth server, allowing users to log in via GitHub, thereby completing the deployment process.

The blog post provides a detailed exploration of deploying a PERN stack application—comprising PostgreSQL, Express, React, and Node—onto AWS, utilizing Pulumi Crosswalk to streamline the process. It highlights the PERN architecture, which involves a database, a stateless server, a client-side server, and user interaction, and emphasizes the advantage of using infrastructure as code, specifically with TypeScript, to align the development of both application and infrastructure. The guide walks through initializing a Pulumi project, configuring PostgreSQL and AWS settings, and setting up a Virtual Private Cloud (VPC) and other necessary AWS components. It explains how to use Pulumi’s Dynamic Provider to manage database schemas and tables and demonstrates deploying the application’s server-side and client-side services to AWS’s Elastic Container Service (ECS) using Crosswalk for efficient infrastructure management. The post concludes by noting the flexibility and scalability offered by Pulumi Crosswalk, with a promise to cover Kubernetes integration in the following week.

Netlify CMS, an open-source content management system, facilitates content editing with a Git workflow, and this article explores deploying it on AWS instead of its native platform, Netlify. The CMS is extracted as a stand-alone React app and is configured to edit website content stored in a separate Github repository, using a configuration file to manage content segments and backend instructions. The deployment process involves building the CMS app, fetching configuration details, creating an S3 bucket for content storage, and establishing a CloudFront distribution for content delivery, with the entire setup managed through Pulumi. The deployment includes configuring DNS records and setting up an SSL certificate for the domain, with the infrastructure defined in a Pulumi project and potentially automated using GitHub Actions for continuous integration. The article also mentions future plans to replace Netlify's Identity Service with a custom OAuth client-server on AWS, highlighting the modularity and flexibility of the deployment process.