Tutorial: Build Your Own Heroku With Cloud... - Muvaffak Onus, & Sidarta Oliveira, Grupo Boticário

Introduction and Overview

In this presentation, the speaker discusses building a custom Heroku-like platform using a cloud-native stack. The topics covered include the Heroku experience, the architecture of the solution, and a hands-on tutorial.

Heroku Experience

• Heroku is known for its simplicity and ease of use.

• Developers can make code changes, push to a git repo, and see their changes go live.

• Heroku provides deployment, scaling, monitoring, and some security guardrails.

• However, it lacks flexibility for complex applications developed by multiple teams.

• It does not allow deploying in an internal network or using custom cloud accounts.

Cloud-Native Stack Solution

• The goal is to create a more customizable version of Heroku with full control.

• Crossplane is used to build an internal cloud platform for provisioning cloud resources.

• Backstage provides a service catalog and software templates for creating new applications.

• Argo CD manages deployments of both application and infrastructure components.

• Developers interact with the platform through Backstage while platform builders design the experience using Crossplane compositions.

Speaker Introduction

The speaker introduces themselves as an engineer at Upbound who maintains Crossplane. They also mention being the Director of Infrastructure and Cloud at Group.

Limitations of Heroku

This section highlights some limitations of using Heroku for larger companies or complex applications.

Limitations

• Heroku does not deploy within an internal network or allow usage of custom cloud accounts.

• It may not be suitable for scenarios requiring advanced scaling or complex configurations.

• As companies grow, they often outgrow the limitations imposed by Heroku's design choices.

Cloud-Native Stack Tools

The speaker introduces the tools that will be used to create the custom Heroku-like platform.

Tools

• Crossplane: Allows building an internal cloud platform for provisioning cloud resources.

• Backstage: Provides a service catalog and software templates for creating new applications.

• Argo CD: Manages deployments of both application and infrastructure components.

High-Level Architecture

A high-level architecture diagram is presented, showcasing how the different tools interact to provide a similar experience to Heroku.

Architecture

• Backstage has software templates and creates git repos with CI/CD pipelines.

• Argo CD deploys both application and infrastructure components.

• Crossplane interacts with the cloud provider to provision resources with one click.

Tutorial Introduction

The tutorial is about getting started with Heroku and exploring its features. The instructor suggests opening the tutorial page to easily copy and paste code snippets.

Getting Started with Heroku

• Open the Heroku website and create a new application.

• Log into Heroku and create a folder for the project.

• Set up the necessary tools and dependencies for the project.

Exploring Heroku Experience

This section focuses on understanding how Heroku works by creating an application and deploying it.

Creating a New Application on Heroku

• Create a new application on Heroku's website.

• Access the newly created application to view its deployment.

Deploying Changes

• Make changes to the code locally.

• Push the changes to the remote Git repository on Heroku.

• Observe that whenever changes are pushed, they are automatically built and deployed by Heroku.

Add-ons Concept

• Discusses add-ons in Heroku, which allow adding infrastructure components to applications.

• Demonstrates how to add an example bucket as an add-on, providing environment variables for accessing it.

Setting Up Tooling for Cluster Deployment

This section covers setting up tooling for cluster deployment using Kind cluster, Backstage, Crossplane, and Argo CD.

Installing Tooling

• Install Kind cluster, Backstage, Crossplane, and Argo CD dependencies.

• Set up namespaces for each component in Kubernetes.

Creating Backstage App

• Use npx command to scaffold a Backstage app.

• Edit TypeScript files of the app to customize its functionality.

Running Initial State of Backstage App

This section focuses on running the initial state of the Backstage app and exploring its functionality.

Running the Backstage App

• Start the Backstage app using npm start.

• Explore the initial state and functionality of the app.

The transcript has been summarized to provide a clear and concise overview of each section.

Backstage UI Overview

In this section, the speaker provides an overview of the initial backstage UI and its features.

Initial Backstage UI

• The initial backstage UI includes an example website and a "Create New Component" feature.

• The catalog part of the UI displays all the software that the company has up and running, including relations, CI/CD, dependencies, and documentation.

• Clicking on a source in the catalog takes you to the corresponding GitHub repository.

• The "Create" part is where most of the work is done. It allows users to choose a template (e.g., Not GST template) and creates a GitHub repository with scaffolding.

Creating a GitHub Token

This section explains how to create a GitHub token for granting permissions to create repositories.

Creating a GitHub Token

• To create a GitHub token, repo and workflow permissions are required.

• Copy the generated token for later use.

Checking Integrations for GitHub Token

Here, the speaker checks if the environment variable for integrating GitHub token is set correctly.

Checking Integrations

• Open app config files (app config local and production) that override core app config based on different environments.

• Verify if the integration of GitHub token is present as an environment variable.

Creating Service with Templates

This section explains how to create a service using templates in three steps: providing a directory for scaffolding, filling templates with user input, publishing to GitHub repository, and registering it back to Backstage instance.

Creating Service

• Provide a directory as a starting point for repository scaffolding.

• Fill in templates with user input (e.g., owner name, repo address).

• Publish the service to a GitHub repository.

• Register the service back to the Backstage instance.

Deploying Service to Kubernetes Cluster

This section covers deploying the service to a Kubernetes cluster using an in-memory database and enabling template options through the UI.

Deploying Service

• Configure deployment settings, including using an in-memory database and enabling template options.

• Build an image and deploy it to a kind cluster.

• Use kubectl port-forward command to access the deployed service.

Creating Secret with GitHub Token

Here, the speaker demonstrates creating a secret that contains the previously generated GitHub token.

Creating Secret

• Create a secret containing the GitHub token for authentication purposes.

Deploying with Manifest

This section explains deploying a simple manifest that includes a deployment, replica, image, service, and service account.

Deploying with Manifest

• Copy the provided manifest file.

• Apply the manifest to deploy the service.

• Verify if the service is up and running.

Opening Deployed Service

The speaker opens the deployed service to check its functionality.

Opening Service

• Access the URL of the deployed service.

• Verify if it is functioning correctly.

Pre-loading Argo CD Images

This section covers pre-loading Argo CD images due to Docker pull limits.

Pre-loading Images

• Run a script to pre-load Argo CD images.

• Install Argo CD in Heroku namespace using pre-loaded images.

Pre-loading Images and Wi-Fi Issues

The speaker mentions pre-loading images for faster loading times. They also discuss how frequently used images are hidden in the Wi-Fi network.

Pre-loading Images

• The speaker mentions that they have pre-loaded the images to ensure faster loading times.

• However, there seems to be an issue with the image loading speed.

Wi-Fi Network and Hidden Images

• The speaker explains that frequently used images are hidden within the Wi-Fi network.

• This is done because everyone pulls these images, causing potential delays in loading.

Killing Processes and Getting Admin Password

The speaker discusses killing processes and obtaining the initial admin password for Argo CD.

Killing Processes

• The speaker suggests killing all processes related to a certain task or operation.

• It is mentioned that these processes have the ability to get back up if not properly terminated.

Obtaining Admin Password

• The speaker plans to retrieve the initial admin password for Argo CD.

• They mention that it may take some time for it to appear.

Port Forwarding and Chrome Access

Port forwarding is set up, and access to Argo CD via Chrome is established.

Port Forwarding

• The speaker instructs someone to port forward a specific connection or service.

• This allows them to establish a connection with Argo CD.

Accessing Argo CD via Chrome

• It is confirmed that access to Argo CD can be achieved through Google Chrome browser.

Taking Risks

The speaker acknowledges taking risks during the process.

Risk-Taking

• The speaker mentions that they are willing to take risks in order to proceed with the task at hand.

Installing Cross Plane and GCP Provider

The speaker plans to install Cross Plane with Helm and then install the GCP provider.

Installing Cross Plane

• The speaker intends to install Cross Plane using Helm, a package manager for Kubernetes.

• This installation is a prerequisite for further steps.

Installing GCP Provider

• The speaker also plans to install the GCP (Google Cloud Platform) provider.

• This is necessary as they will be provisioning a bucket from GCP in their scaffolded application.

Starting with Backstage Example Scaffolding

The speaker explains that they will begin with a simple template for Backstage example scaffolding.

Starting Point

• The speaker states that they will start by using a basic template for Backstage example scaffolding.

• This initial template will serve as a validation step before proceeding further.

Creating Provider Config Object

The speaker creates a provider config object and discusses the need for providing GCP credentials.

Creating Provider Config Object

• The speaker creates a provider config object related to the GCP provider.

• This object is used to configure and authenticate access to Google Cloud Platform services.

Providing GCP Credentials

• It is mentioned that providing GCP credentials is necessary when installing the GCP provider.

• The speaker assumes that the required environment variable for their service account in GCP is already available.

Creating Repo and Fetching Template from GitHub

A new repository is created, and the template is fetched from their own GitHub repository.

Creating a New Repo

• The speaker creates a new repository, which will be used for the template and scaffolding process.

• In a company setting, this repository would typically be maintained by a platform team.

Fetching Template from GitHub

• The speaker mentions that they will fetch the template from their own GitHub repository.

• This allows them to use their own customized template with specific code and configurations.

Explaining Template YAML and Steps

The speaker explains the structure of the template YAML file and its steps.

Template YAML Structure

• The speaker describes the structure of the template YAML file used in Backstage scaffolding.

• It includes properties that prompt users for information such as service name, owner, and location.

Steps in Template YAML

• The speaker compares the steps in the template YAML file to GitHub actions.

• Each step involves choosing an action, providing inputs and outputs, and executing them one by one.

Creating Skeleton Folder and Catalog Info

The speaker creates a skeleton folder for the repo and discusses catalog info.

Creating Skeleton Folder

• A skeleton folder is created within the repository.

• This folder contains Go templates that Backstage parses and replaces during scaffolding.

Catalog Info

• Catalog info is mentioned as an essential part of registering services to Backstage.

• A catalog-info.yaml file is required for this registration process.

Adding Package JSON and Basic Code

Package JSON is added, along with basic code for a "Hello World" application.

Adding Package JSON

• Package JSON file is included in the skeleton folder.

• This file likely contains dependencies and other package-related information.

Basic Code - "Hello World"

• The speaker adds basic code for a "Hello World" application.

• They mention that certain parts of the code will be replaced with user input, such as service name and owner.

First Backstage Template Created

The first Backstage template is created and ready to be pushed to the repository.

First Backstage Template

• The speaker announces the completion of their first Backstage template.

• They are now ready to commit and push the template to the repository.

• Afterward, they plan to create a new service in Backstage.

Importing a Template YAML to Backstage

The speaker discusses importing a template YAML file to Backstage, which has integration with GitHub. They demonstrate how to import the template and create a "Hello World" application on Kubernetes.

Importing the Template YAML

• To import the template YAML file to Backstage, the speaker takes the URL of the template YAML.

• Backstage has integration with GitHub, allowing it to fetch resources from repositories.

• The imported template is used to create a "Hello World" application on Kubernetes.

Customizing Templates

• Templates can be customized by modifying certain parts, such as image tagging or image repository.

• Templating in scaffolding code allows for easy customization of resources like images and GitHub actions.

Cloning and Running the Application

• The speaker clones the newly created repository and runs it using npm start.

• The application is accessed through HTTP instead of HTTPS.

Summary

The speaker demonstrates how to import a template YAML file into Backstage and customize it to create a "Hello World" application on Kubernetes. They also highlight the importance of templating in scaffolding code for easy customization.

New Section

In this section, the speaker discusses creating a GitHub action folder and making changes to the ci.tml file.

Creating the GitHub Action Folder

• The speaker mentions that they are going to create a GitHub action folder.

Making Changes to ci.tml

• The speaker realizes there was an error and says "oops".

• They confirm that they will make changes in the ci.tml file.

• The speaker mentions creating a new commit and pushing a new image template.

• They proceed to register the new template.

• The speaker explains how they can choose from various software templates in the create menu.

• They mention creating a repository and state that it will involve more steps than before.

• After the repository is created, they observe the initial commit, GitHub workflows, and image building process.

• The images are pushed to GitHub packages for consumption.

New Section

In this section, the speaker talks about building various components using Scaffolding in GitHub actions.

Building Components with Scaffolding

• The speaker mentions that Scaffolding in GitHub actions allows for different technologies like image scanning without developers needing to be careful or have specific instructions on how to create a new project.

• They highlight that packages are pushed without any developer intervention.

• The speaker plans to create another template that is similar to the previous one but with some changes.

• They proceed to change the name in the template.

New Section

In this section, the speaker discusses adding a custom action to Backstage and explains the extensibility story of Backstage.

Adding Custom Action to Backstage

• The speaker mentions adding a custom action to Backstage and explains that they had to write a new module for it to interact with Kubernetes.

• They clarify that while there is core Kubernetes integration with Backstage, it only reads files and shows status based on labels, but does not have actions like creating deployments on the cluster.

• The speaker emphasizes that they don't want GitHub repositories to have access to their private cluster, so they created a separate custom action for interacting with Kubernetes.

New Section

In this section, the speaker demonstrates how npm packages can be added in Backstage.

Adding npm Packages in Backstage

• The speaker navigates through the source plugins and scaffolder directories in Backstage.

• They explain that by registering npm packages in the create plugins section of the application, they can add them effectively.

• The speaker adds two actions from their package - Argo CD create application and wait for last workflow - as part of initializing built-in actions.

New Section

In this section, the speaker tests the actions in Backstage and ensures that the backstage service account has the necessary permissions.

Testing Actions in Backstage

• The speaker demonstrates how to create actions using an endpoint called "create" in Backstage.

• They confirm that their actions are registered successfully.

• The speaker mentions that the backstage service account needs permissions to create Argo CD applications and proceeds to grant those permissions.

Argo CD Image Updater

The speaker discusses a project called Argo CD image updater and its compatibility issues with Google GitHub container registry. They mention the need to rebuild templates and enable importing from the UI.

Argo CD Image Updater

• The project called Argo CD image updater is not working with Google GitHub container registry.

• There is a plan to make changes automatically propagate, but for now, it needs manual updates.

• Rebuilding templates is necessary, and importing from the UI has been enabled.

• The backstage pod needs to be killed for it to pick up the new image.

Updating Templates in Argo CD

The speaker explains the process of updating templates in Argo CD and mentions adding new steps to scaffolding actions.

Updating Templates

• Before registering, there is a need to wait for the workflow to complete in template.tml.

• After saving changes, refreshing the template will show the updated version.

• Registering again will display a "refresh" button instead of "create".

Importing Templates in Argo CD

The speaker demonstrates how to import newly created templates into Argo CD.

Importing Templates

• Existing templates are removed due to using email database.

• A newly created template (article cd1 template DML) is registered and imported.

• Going through the same cycle one by one with different setups.

Fixing Template Issues

The speaker encounters an issue with missing steps in their template and resolves it.

Fixing Template Issues

• Checking if all changes have been committed before proceeding.

• Saving the changes to ensure they are applied correctly.

Creating Actions and Moving to Cross Plane

The speaker creates new actions and transitions to working with Cross Plane.

Creating Actions

• Pushing a new template and creating another action.

• Transitioning to working with Cross Plane for infrastructure resources.

Working with Cross Plane

The speaker explains the process of defining an API for buckets in Cross Plane and includes encryption and service account management.

Working with Cross Plane

• Defining an API for buckets, including parameters like location.

• Including custom resource in the hand chart.

• Managing service accounts, secret publishing, and encryption using composition.

• Installing Cross Plane to the cluster but not to templates or the git repo.

Timestamps have been associated with relevant bullet points.

Changing the Template Name

In this section, the speaker discusses changing the name of a template to "anyone" instead of "GS application with bucket dress."

Changing the Template Name

• The speaker suggests changing the name of the template to "anyone" instead of "GS application with bucket dress."

• The new steps for the template did not appear in this section.

Adding New Steps to the Template

The speaker mentions adding new steps to the template.

Adding New Steps to the Template

• The speaker plans to add new steps to the template.

• No further details are provided in this section.

Fixing Chart Version and Creating Argo CD Application

This section focuses on fixing chart version issues and creating an Argo CD application.

Fixing Chart Version and Creating Argo CD Application

• An Argo CD application is created, targeting a published chart.

• There was an issue with the chart having an incorrect version, which will be fixed in GitHub CI.

• The image chart and Argo CD application are now fixed.

Including Bucket in Chart Definition

This section discusses including a bucket in the chart definition.

Including Bucket in Chart Definition

• The plan is to include a bucket in the chart definition.

• A bucket is needed for a service that requires it.

Returning to Crossplane Part

The speaker goes back to discussing Crossplane.

Returning to Crossplane Part

• The speaker returns to discussing Crossplane.

• No further details are provided in this section.

Simplifying Developer Experience with Credentials Secret Mounting

This section focuses on simplifying the developer experience by mounting credentials secret to the service.

Simplifying Developer Experience with Credentials Secret Mounting

• The speaker explains that developers only need to use environment variables and don't have to deal with GCP credentials directly.

• Similar to Heroku's add-ons experience, developers can simply use environment variables without needing to know specific details about GCP credentials.

Updating Hello World Application for Google Cloud Storage Interaction

This section discusses updating the Hello World application to interact with Google Cloud Storage.

Updating Hello World Application for Google Cloud Storage Interaction

• The Hello World application needs to be updated as it now requires interaction with Google Cloud Storage.

• A small TypeScript code snippet is provided for this purpose.

Functionality of the Updated Server.js File

This section provides an overview of the functionality of the updated server.js file.

Functionality of the Updated Server.js File

• The updated server.js file generates a file every 30 seconds, uploads it, and lists all files from the bucket.

• This will be the new application functionality.

Finalizing Package and Deployment

The speaker finalizes the package and deployment process.

Finalizing Package and Deployment

• The server.js file and package are ready for deployment.

• No further details are provided in this section.

Verifying Bucket YAML in Chart Definition

This section focuses on verifying if the bucket YAML is present in the chart definition.

Verifying Bucket YAML in Chart Definition

• It is important to ensure that the bucket YAML is present in the chart definition.

• No further details are provided in this section.

Mounting Google Credentials JSON for GCP Client Access

This section discusses mounting the Google credentials JSON for GCP client access.

Mounting Google Credentials JSON for GCP Client Access

• The deployment definition needs to be changed to mount the Google credentials JSON as "chris.json" and provide its address for the GCP client to access it.

• Crossplane composition handles the connection details and secret keys, making it easier to manage.

Deploying the Sky

This section focuses on deploying the application.

Deploying the Sky

• The speaker deploys the application.

• No further details are provided in this section.

Checking Metadata of the Template

The speaker checks the metadata of the template.

Checking Metadata of the Template

• The speaker verifies if there have been any changes in the metadata of the template.

• No further details are provided in this section.

Pushing Template to Repository and Registering in Argo CD UI

This section discusses pushing a template to a repository and registering it in Argo CD UI.

Pushing Template to Repository and Registering in Argo CD UI

• The template is pushed to a repository and will be used in Argo CD UI.

• No further details are provided in this section.

Next Steps and Customization Options with GitHub Actions

This section explores next steps and customization options using GitHub Actions.

Next Steps and Customization Options with GitHub Actions

• Instead of Argo CD picking up from the code repository, GitHub actions can be used to open a PR, go through checks, and update Argo CD applications from a separate deployment repository.

• Different choices can be made based on individual requirements.

Infrastructure Deployment Process

In this section, the speaker discusses the process of deploying infrastructure using a bucket and RDS instance. They highlight the convenience of not having to provide credentials and how it integrates with the application pipeline.

Deploying Infrastructure with Bucket and RDS Instance

• The speaker mentions that they have added a bucket and can also add an RDS instance using YAML files in their Git repository.

• By adding specific configurations, such as Rd assistance, storage, VPN, or IAM roles, users can create secure RDS instances within their VPN without needing to provide credentials.

• The deployment process is streamlined by adding another YAML file to the Git repository and triggering a new release through git push.

Troubleshooting Image Fetching Issue

The speaker encounters an issue while trying to fetch an image from GitHub container registry and attempts to troubleshoot it.

• The speaker notices that there is an issue with fetching the image from GitHub container registry due to slow internet connectivity.

• When asked about the problem, they mention that it might be related to long URLs or incorrect URL configuration.

• They make corrections in one of the skeletons by editing the URL to fix the issue.

Deployment Status and Resource Creation

The speaker provides an overview of various resources being created during deployment and highlights their order of creation.

• Multiple resources are being created during deployment, including service accounts, service account keys, crypto keys, queues, etc.

• These resources are created before creating buckets because they are required for bucket creation. For example, KMS key names need to be provided for bucket creation.

• The speaker observes that there is an error related to a missing container port value in one of the deployments.

Troubleshooting Deployment Issue

The speaker encounters an issue with deployment and attempts to troubleshoot it by editing files and deleting/re-syncing resources.

• The speaker tries to fix the missing container port issue by editing the deployment file in the cluster.

• However, they face difficulties applying the changes and decide to delete and sync the deployment again.

• Despite multiple attempts, they are unable to resolve the issue and express frustration about encountering similar problems before.

Correcting Repository Configuration

The speaker realizes that there is an error in repository configuration and makes corrections to resolve it.

• The speaker corrects a mistake in repository configuration related to automatic creation of namespaces.

• They mention using "ghcr" instead of "git ham chart" for repository configuration.

• Additionally, they mention creating a new template and repository to refresh configurations.

Improvements and Next Steps

The speaker discusses potential improvements for future steps, such as having different clusters and branches in Git repositories for specific environments (e.g., Dev, Prod).

• The speaker suggests that after following this tutorial, users can explore further improvements like having different clusters or branches in their Git repositories for different environments (e.g., Dev, Prod).

• They compare this approach to Heroku's pipelines concept where specific branches push changes to designated clusters.

• By implementing these improvements, users can have a similar experience to Heroku while maintaining control over their network configuration and infrastructure.

Verifying Deployment Fix

The speaker verifies if the previous fix has resolved the deployment issue but finds that it hasn't been successful yet.

• The speaker checks if the previous fix has resolved the deployment issue but realizes that it hasn't been successful.

• They suspect that they may have added the wrong template CML file and decide to copy it again.

Successful Deployment Fix

The speaker successfully fixes the deployment issue by editing files and refreshing configurations.

• After making corrections, the speaker successfully resolves the missing container port issue in their deployment.

• They refresh templates and create a new repository to ensure that the fix is applied correctly.

• Finally, they confirm that this time the deployment should work as expected.

Deleting Old Repos

The speaker mentions deleting old repositories.

Deleting Old Repos

• The speaker suggests deleting the old repositories.

Repo Creation

The speaker mentions that the repository has been created and they will take a quick look at it.

Repo Creation

• The speaker confirms that the repository has been created.

• They mention taking a quick look at it.

Chart Templates Service

The speaker briefly discusses the chart templates service and waits for image and bucket provisioning to complete.

Chart Templates Service

• The speaker mentions the chart templates service.

• They wait for the image and bucket provisioning to complete.

Questions about Architecture and Frameworks

The speaker asks if there are any questions about the architecture or specific steps or frameworks used.

Questions about Architecture and Frameworks

• The speaker asks if there are any questions about the architecture or specific steps or frameworks used.

Cross-plane Importing Existing Infrastructure

A question is asked about whether Cross-plane can import existing infrastructure, and the answer is provided.

Cross-plane Importing Existing Infrastructure

• A question is asked about whether Cross-plane can import existing infrastructure.

• It is explained that Cross-plane resources have an external name annotation which allows them to identify resources in external APIs like AWS.

• By using this annotation, it is possible to adopt existing resources as if they were created by Cross-plane.

• It is mentioned that this can also be done in scaffolding and composition by patching the external name with input parameters from users.

Using Existing Cluster or RDS Instance

The speaker explains how in composition, users can choose to use an existing cluster or RDS instance by patching the external name with the input parameter from the user.

Using Existing Cluster or RDS Instance

• It is explained that in composition, users can choose to use an existing cluster or RDS instance.

• This can be done by patching the external name with the input parameter from the user when creating a new application.

Questions about Parts

The speaker asks if there are any other questions about these parts.

Questions about Parts

• The speaker asks if there are any other questions about these parts.

Small Fix

The speaker mentions making a small fix and proceeds to edit it.

Small Fix

• The speaker mentions making a small fix.

• They proceed to edit it.

Container Creation and Crypto Key Events

The speaker observes that containers are being created and crypto key events are being generated while waiting for bucket provisioning to complete.

Container Creation and Crypto Key Events

• Containers are observed to be in the process of creation.

• Crypto key events related to container creation are mentioned.

Credential Issue

The speaker suspects that their credentials might be incorrect and plans to apply a script.

Credential Issue

• The speaker suspects that their credentials might be incorrect.

• They plan to apply a script.

Handing Over to Siddhartha

The speaker hands over to Siddhartha to showcase the production environment built with Backstage, Crossplane, Argo CD, and other integrated tools.

Handing Over to Siddhartha

• The speaker hands over to Siddhartha.

• Siddhartha will showcase the production environment built with Backstage, Crossplane, Argo CD, and other integrated tools.

Introduction to Grupo Boticário

Siddhartha introduces Grupo Boticário as a Brazilian beauty company with a complex ecosystem.

Introduction to Grupo Boticário

• Siddhartha introduces Grupo Boticário as a Brazilian beauty company.

• They mention having 45 years of foundation and being present in Brazil and 15 other countries.

• Grupo Boticário is described as having a complex ecosystem due to its involvement in various aspects of the beauty industry.

• They mention being an omnichannel company with e-commerce, physical stores, door-to-door sales, and distribution channels.

Digital Transformation at Grupo Boticário

Siddhartha explains that Grupo Boticário embarked on a digital transformation journey involving moving data centers to the cloud, breaking monolithic applications into microservices, and adopting open-source technologies.

Digital Transformation at Grupo Boticário

• Siddhartha explains that Grupo Boticário started a digital transformation journey.

• They mention moving data centers to the cloud while breaking monolithic applications into microservices.

• Adoption of open-source technologies like Kafka and APG is mentioned.

Internal Developer Platform at Grupo Boticário

Siddhartha discusses the internal developer platform called PDD (in Portuguese), which provides tools, templates, utilities, and automation to make developers' day-to-day tasks easier.

Internal Developer Platform at Grupo Boticário

• Siddhartha discusses the internal developer platform called PDD (in Portuguese).

• The platform provides tools, templates, utilities, and automation.

• Its purpose is to make developers' day-to-day tasks easier.

Application Deployment Made Easy

Siddhartha mentions that developers can easily deploy production-grade applications by providing basic information through the internal developer platform.

Application Deployment Made Easy

• Developers can deploy production-grade applications easily.

• They only need to provide basic information through the internal developer platform.

The transcript provided does not contain any timestamps for some sections.

Developers Workflow in Backstage Interface

In this section, the speaker explains the workflow for developers using the Backstage interface to create new components and provision infrastructure.

Creating a New Component

• Developers can choose from a variety of templates for creating new components.

• Templates include golden paths for front-end applications, serverless computing, and more.

• Minimal documentation is provided for each template to guide developers on how it works.

• Developers fill in the required information such as GitHub repository and component details.

Provisioning Infrastructure

• Developers have autonomy to create and configure infrastructure for their components.

• They can specify parameters such as database type, version, and additional resources.

• The process is streamlined with minimal information required from developers.

• The infrastructure provisioning takes around 10 minutes.

Viewing Application Information

• Developers can access the Backstage catalog to view information about their applications and repositories.

• They can see details like application state, New Relic information, SonarQube analysis, and CI steps (using GitHub Actions).

Repository Structure

• The repository contains both the application code (Helm values) and infrastructure code.

• Infrastructure parameters are populated automatically during scaffolding.

• Tagging is implemented to manage costs effectively.

Integration with Tooling

• Neccessary tooling such as New Relic integration and database credentials are automatically injected into the application.

Benefits of this Approach

• Autonomy: Developers have the freedom to provision resources without relying on the infrastructure team.

• Reduced Delivery Time: Provisioning time has been reduced from 7 days to approximately 10 minutes.

• Standardization: By keeping application and infrastructure code in the same repository, teams can collaborate more effectively.

God damn it

The speaker expresses frustration.

Frustration

• The speaker exclaims "God damn it" in frustration.

Okay

The speaker acknowledges something.

Acknowledgment

• The speaker says "okay" to indicate agreement or understanding.