Brainboard now seamlessly integrates with the Azure DevOps Terraform Provider, enabling users to manage their Azure DevOps resources using Terraform through Brainboard’s intuitive design interface.

Click on the top left-corner to switch to it 😇

• Brainboard supports AWS, Azure, GCP & OCI.
• For unsupported TF provider, a workaround exist to use custom resources.

• Direct integration with the TF provider azure_devops. Users can now design, configure, and manage Azure DevOps resources right within Brainboard.
• Drag-and-drop interface for adding and configuring Azure DevOps resources such as repositories, pipelines, and service connections, directly within your infrastructure designs.
• Automatic generation of Terraform configurations (.tf files) for Azure DevOps resources, managed alongside your other infrastructure code, all within Brainboard.
• Visual mapping between Azure DevOps resources and other infrastructure components, enabling clearer and more efficient orchestration of multi-service environments.

🐞 FIXED by Batman 🦸🏻‍♂️

• Git Source Update: When using a module from a Git source, Brainboard automatically fetches the latest update. However, there are instances where this automatic update fails to occur. In such cases, manual synchronization is required to ensure the latest module version is obtained.
• Module Update Inconsistency: When making changes to a custom source module, Brainboard fails to update all architectures that use this module consistently. This leads to outdated module versions being used in some architectures.
• Improved Manual Synchronization: We have implemented enhancements to the manual synchronization feature for modules sourced from Git. Brainboard now reliably fetches the latest module update when initiated manually. This ensures that users have access to the most up-to-date version of the module.
• Inheritance System Issue: For a specific period of one day, there was a problem with the inheritance system. The issue caused inconsistencies and unexpected behavior when inheriting modules. However, the problem was identified and fixed on the same day.
• Code Fix for Network Ranges and IPs: We have resolved an issue related to code changes that involve network ranges and IP addresses. The fix ensures accurate handling and processing of these elements.
• Improved Variable Creation from ID Card Field: The process of automatically creating variables from the ID card field has been enhanced. The improvements aim to provide better accuracy and reliability when generating variables from this specific field.
• Import modules: When importing modules that already exist, we display the appropriate error message to better explain the root cause of the issue.
• Git Integrations: Error messages that prevented the saving of Git configurations have been resolved.
• Deploy: We noticed an issue with the Deploy tab causing infinite loading, which affected a few architectures. We resolved the problem immediately and apologize for any errors this may have caused and any impact on your deployment cycle.
• Terraform Plan: The Plan button was malfunctioning and displaying a warning about the concurrency limit, which was not intended. We apologize for any confusion or inconvenience this may have caused. The issue has been addressed and the warning will no longer appear.

⏮️ Rewind from Mike Tyson of the Cloud

• 🤖 Terraform X GPT: What to expect?
• 🤖 ChatGPT for DevOps: Best Practices, Use Cases, and Warnings

• 🦸‍♀️ The 3 most advanced Terraform commands made simple in Brainboard
• ⛅️ Moving to IaC: Challenges and Best practices
• 🧠 Become a Visual GUI: The New Era of Cloud Infrastructures
• 🌊 Writing Terraform custom code for unsupported resources in Brainboard
• 🚀 Become A DevOps Engineer in 2023: A Comprehensive Guide
• 🧱 Top 10 reasons your architecture library isn’t helpful and how to fix them
• 💲 FinOps: Techniques on how to save $7M of cloud cost

• 📌 Azure Eventhub hands-on with CI/CD workflow with Terraform, Tfsec, Infracost,Drift detection
• 🚀 Automating Multiple Environments with Terraform on Brainboard
• 💰 10x Faster Cloud Infrastructure Delivery: A FinTech Scaleup’s Success Story with Brainboard
• 🗺️ Azure Spring App Infrastructure-CI/CD workflow with Terraform, Tfsec, Infracost and Drift detection
• 🗺️ Azure Landing Zone Baseline & 4 Terraform open-source tools to make it secure and cost-efficient
• 🗺️ How to use Azure DNS Private Resolver + Terraform for securing your Azure Infrastructures**
• 🗺️ AWS EKS Kubernetes Cluster - Terraform+Tfsec+Infracost=Automate Cloud Cost & Security Management

🧼 IMPROVED

We've made some performance enhancements to the:

• We are happy to announce that Brainboard is available for both: AWS Marketplace, Azure Marketplace
• Inheritance now supports multiple resources - While designing your cloud architecture, you can now move 2+ resources at the same time into a container.
• The Brainboard migration tool supports multi-lines strings.
• Export architecture as JSON - We added the export feature to allow all our users to either backup their architecture, to migrate them from one account to another one, to share them with the support when needed. You are now able to export and import any Brainboard architecture easily.
• Hide the default value for sensitive variables.
• Add the support of Terraform Cloud remote backend.
• All Terraform versions are now available in Brainboard CI/CD Engine.

🐞 FIXED

• You can now download / search the CI/CD output.
• We now list all your GitLab projects in Git configuration, before limited to 20.
• We fixed an error during pull request / merge request when the target branch already exists.
• Visual indicator when cloud resources are in Icon Only mode (Terraform code not generated)
• When using synced architectures, variables creation and updates are now synced to both / more architectures.
• We removed the issues linked to the scrolling and wrong colors on selection, in README.
• We removed quotes around ignore_changes (Terraform lifecycle options)
• Our new system will always choose the best Terraform file to show based on your architecture diagram.

⏮️ Rewind

• 📌 Brainboard CI/CD designed specifically for the infrastructure
• 🔐Azure Sentinel+Terraform: 3 Key Benefits of Azure Sentinel for Protecting Your Azure Infrastructure
• 📌 AWS Landing Zone with Terraform - Save time with automated checks of your Terraform scripts
• 😍 Standardized Self Service infrastructure provisioning with Terraform - Easy Azure automation
• 👨‍💻 Boost your career as a cloud architect & DevOps with these top 9 Terraform Courses & Workshops
• 🗺️ Azure Multi Subscription Landing Zone - 6 Tips and Solutions for Cloud Architects and DevOps
• 🗺️ 🚀 3 reasons why AWS Elastic Beanstalk can help in overcoming deployment challenges
• ♻️ 5 Best Practices for Maintaining Consistency Across Cloud Environments

🧼 IMPROVED

1. 

   Clearer output for clearer decisions: When deploying your cloud architecture, we improved the output of your Terraform code, CI/CD workflow and Terraform actions. That will enable you to make clearer decisions, apart from all distractions, having all your cloud environment in one solution.
2. New year, new design system: We've been shipping a lot lately. Our image you perceive of Brainboard count for us. So we heard your feedback and designed internally our new logo, images, and experience across the website, the onboarding, and the application with new colors and visual improvements. 
3. Documentation: A new documentation was just released, improving product clarification and explanation. This improved documentation will help users better understand our product and how to best use it. Get excited about next week's website launch, featuring brand-new features and a more modern design! You can visit the documentation here.

🐞 FIXED

We've resolved reported issues that were causing occasional crashes when, for example:

1. Specify a different brand when doing a pull request:
   • We now allow you to specify a different branch in the base branch field in the pull request modal, when creating a pull request. This means that you are able to select which branch they want to merge their changes into, rather than being restricted to a specific branch such as “main”. This feature can be useful for organizations that use multiple branches for development and testing, as it allows developers to easily collaborate on code changes and merge them into the appropriate branch for deployment. Additionally, it can help to maintain the versioning and history of the Terraform codebase.
2. Variable type not saved:
   • Problem: This bug fix addresses an issue where a new variable is not correctly saving the type information during the creation or modification process. This can cause problems with the functionality of the application, as the type of variable is important for determining how the application should handle and interact with the variable's value.
   • Solution: The fix involves updating the Terraform code that is responsible for handling the creation and modification of variables to properly save the type information. This could involve checking for missing or incorrect type information, and adding code to handle this properly. Additionally, it also involves testing the updated Terraform code to ensure that the bug is resolved and that the new variables are being created and modified correctly with the correct type information. 
3. Custom group TF file broken:
   • Problem: The bug fix addresses an issue with the functionality that retrieves custom group files in Terraform. The bug is related to the fact that when a group starts with 'f' or 't' the retrieval of the custom group file is broken. The issue with the Terraform configuration for the “test” group, as the test.tf file should contain the necessary information for provisioning and managing the infrastructure for that group, but it is empty. 
   • Solution: Create an architecture or a blueprint of the infrastructure using Terraform. Add 3–4 nodes on the design canvas, which are servers or machines that make up the cloud infrastructure. Change the group of 2 of the nodes to “test” group. Now, retrieve the test.tf file, which should contain the Terraform configuration for the “test” group.
4. Scroll through a big output:
   • Problem: The bug fix addresses an issue with the performance of scrolling through the output of the “plan” in Terraform. The bug is causing the scrolling to be slow and unresponsive, with a delay of 2–3 seconds before the update or the next lines are displayed.
   • Solution: We optimized the code that handles the output display and scrolling by reducing the number of updates and unnecessary calculations. We always make sure the data is being loaded and processed efficiently.
5. Import Multiple strings:
   • Problem: The bug fix addresses an issue with the way Brainboard import Terraform code that contains "<<EOF" and "EOF" for a field. The bug causes these characters to be changed into strings which causes issues in the interpretation of the code.
   • Solution: Update the import code to properly handle these characters. We make sure the code that reads and interpret the imported Terraform code is able to handle these characters correctly.
6. Feedback survey:
   • Problem: We noticed that the feedback form brought aggressive prompts to you, builders and cloud architects. 
   • Solution: We've disabled it for now. Please continue to contribute to the Slack community and contact us if any improvements need to be fixed. We generally respond within 6h. 
7. Editing node title:

• Problem: The bug fixes you addresses an issue with the way the editing of the title of a node behaves in Brainboard's canvas. The bug causes the title of the selected node to change when editing the title of a different node that is not selected.
• Solution: We added a check to verify that the correct node is being edited, or by making sure the system is keeping track of the correct selected node.

🧼 IMPROVED

We've made some performance enhancements to the:

1. CI/CD Engine: We've just introduced a feature for approval tasks, which allows users to request and receive approval before deploying code changes to a production environment. This can be useful for ensuring that code changes have been reviewed and tested properly before they are deployed to a live environment, and can help to prevent errors or issues that could negatively impact the performance or functionality of the system.
2. Import: We continue to improve the import feature. This week, we've focused on database use case. Now, you can import schema and documentation. A schema is the structure of the database and the rules on how the data should be organized, while a document is a single unit of data stored within the database.
3. Deleting cloud architectures: When soft-deleting cloud architectures, we now soft delete all related objects including workflow(s), pipelines, jobs, deployments, git integrations, and terraform settings.

📆 Replay: Understand CI/CD strategies & Best Practices 

• 0:02:20 CI/CD Day
• 0:04:40 CI/CD in Application world 
• 0:07:00 CI/CD for the app  
• 0:13:47 IaC Best practices 
• 0:20:00 Application vs. Infrastructure 
• 0:28:00 IaC languages 
• 0:34:40 Existing solutions 
• 0:38:40 Commonalities & Challenges
• 0:42:10 What is expected from a CI/CD solution 
• 0:48:10 Some of useful open-source tools 
• 0:52:00 CI/CD Best practices 
• 0:57:40 Successful Implementation 
• 1:05:20 Brainboard CI/CD Engine—demo tour 
• 1:05:50 Design your first CI/CD workflow visually 
• 1:09:00 CI/CD outputs 
• 1:10:40 Create a CI/CD pipeline template

🐞 FIXED

We've resolved reported issues that were causing occasional crashes when, for example:

1. Storage Container already exists issue:
   • Problem: When creating a new Storage Container in Brainboard, if the container already exists in AWS or Azure, the application would fail.
   • Solution: We have implemented a check that verifies if the container already exists in the specified cloud provider before attempting to create it. If the container already exists, Brainboard will no longer fail and will instead display a message indicating that the container already exists.
2. Git Personal Token Editing Error:
   • Problem: When editing only one field in the Git Personal Token, an error occurred and the changes were not saved.
   • Solution: We have identified the problem and fixed the issue with the Git Personal Token editing process. Users should now be able to edit any field in the token without encountering errors.
3. Terraform Block Removal:
   • Problem: When importing Terraform files, such as backend.tf that contains a Terraform block and many providers block, the Terraform block was automatically removed.
   • Solution: We have identified the problem and fixed the issue with the Terraform block removal during import. The Terraform block should now be retained and not removed during the import process.
4. Map variable syntax issue:
   • Problem: When importing a Terraform file that contains a map as the type of variable and the values are defined in terraform.tfvars, the values were changed and replaced with an invalid Terraform syntax, causing the plan to fail,
   • Solution: We have identified the problem and fixed the issue with the map variable syntax. The values should now be imported correctly and retain their original syntax.
5. Validation Block Import:
   • Problem: When importing from Git or files, for example, a Terraform code that contains a validation block, the variables validation block was not imported in Brainboard.
   • Solution: We have identified the problem and fixed the issue with the validation block import. The variables validation block should now be imported correctly and be visible in Brainboard.
6. Terraform Variables Modal:
   • Problem: The Terraform variable modal was changing every time it was opened or when doing a pull request. This caused confusion and made it difficult to track changes.
   • Solution: We have made changes to the Terraform variable modal, so it will no longer change every time it is opened or when doing a pull request. This will make it easier to track changes and manage variables.
7. Default Terraform Code File:
   • Problem: The default Terraform code file was main.tf, but it was causing confusion when working on a different resource file.
   • Solution: We have changed the default Terraform code file to be the resource file that the user is currently working on. This will make it easier to manage multiple resource files and keep track of changes.

About

1. Collaborate effectively with team members: PR/MR provide a way for team members to propose changes to the infrastructure codebase and review and discuss them with other team members before merging them into the main branch. This allows for better collaboration and communication within the team.
2. Implement code review and testing processes: PR/MR provides a way to implement a code review process, where other team members review changes to the infrastructure codebase before being merged. This can help identify and fix bugs and issues before they are deployed to production.
3. Track changes to the infrastructure codebase: PR/MR provides a way to track changes to the codebase, including who made the change and why making it easier to understand how the infrastructure has evolved.
4. Rollback changes: PR/MR provides a way to roll back changes to the infrastructure codebase if something goes wrong. This can be done by reverting the merge commit or using version control tools like Git to revert specific changes.
5. Isolate changes: PR/MR provides a way to isolate changes, meaning that changes are committed and tested in a separate branch before merging into the main branch. This allows for keeping the main branch stable and ready to deploy at all times.
6. Implement automated testing and integration: PR/MR provides a way to implement an automated testing and integration process. This can be done by integrating the VCS with a continuous integration and deployment tool, which can run automated tests and deploy changes to different environments.

• One of the improvements is that it eliminates missing fields when configuring specific cloud resources. You no longer have to worry about missing important information when setting up your cloud infrastructure. 
• The ID card allows for multi-block everywhere, allowing for better customization options. This can be achieved by using hardcode, a powerful tool for making changes to the infrastructure. 

1. Using the "depends_on" argument in resource blocks allows you to specify that a resource depends on another resource and must be created after it.
2. Using the "${resource.name.attribute}" syntax allows you to reference the attributes of one resource in the configuration of another resource.
3. Using the "data" blocks to retrieve information from external resources allows you to retrieve information from existing resources and use it to configure new resources.
4. Terraform modules allow you to group resources and reuse them across multiple configurations. This is a way to organize your resources and share them with others.
5. Using Terraform's variables: Terraform variables can store resource information and reference it in multiple places in your configuration.

In Brainboard, this applied for all cloud providers supported (Azure, OCI, GCP, Scaleway)

1. Use variables to define the regions you want to deploy your infrastructure in: By using Terraform variables; you can specify which regions you want to deploy your infrastructure in and make it easy to change or add regions in the future.
2. Use variables to define the specific resources in each region: By using Terraform variables, you can specify the specific resources you want to deploy in each region. This allows you to create different resource configurations for different regions easily.
3. Use variables to define the AMI ID: By using Terraform variables, you can specify the AMI ID (Amazon Machine Image) you want to use in each region. This allows you to use different AMIs for different regions.
4. Use variables to define the subnets and availability zones: By using Terraform variables, you can specify the subnets and availability zones that you want to use in each region. This allows you to use different subnets and availability zones for different regions.
5. Use variables to define the security group: Terraform variables can specify the security group you want to use in each region. This allows you to use different security groups for different regions.

variable "region" {
  default = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = var.ami
  instance_type = "t2.micro"
  region        = var.region
}

*The ID cards would represent different cloud resources, such as virtual machines, load balancers, and storage volumes. By dragging and dropping these ID cards onto a canvas, users could quickly and easily design their desired cloud infrastructure.

Once the diagram is designed, it would also be actionable, meaning that the user could deploy their cloud infrastructure with a single click. Brainboard would then automatically provision and configure the necessary resources based on the ID cards that were used in the design.

Brainboard greatly simplify the process of designing and deploying cloud infrastructure, as it would provide users with a visual, intuitive way to work with the resources. Additionally, the use of ID cards could also enable users to easily share and reuse their cloud infrastructure designs with others.

Before

* tfvars files are Terraform configuration files that store variables for a Terraform configuration. They typically have the file extension .tfvars and are used to set values for variables that are used in Terraform configuration files. These files allow you to store sensitive information like credentials and other sensitive data, which you can use in your Terraform configuration, but without having to hard-code them in your .tf files.

Introducing Import Azure

• In GCP, Terraform tags are used to add metadata to resources such as virtual machines, disk, and networks. These tags can be used to identify, organize and manage resources within GCP. For example, you can use tags to organize resources by environment, application, or project, and you can also use tags to identify resources for billing and cost management.
• In AWS, tags are used similarly to GCP, but they are referred to as resource tags. AWS tags provide a way to organize and categorize resources within an AWS account.

*In Terraform, a local is a way to assign a value to a variable, and it's only accessible within the same module where it's defined. A local variable can't be accessed outside of the module where it's defined. It can be used to store temporary values that are used within a module and it's not exposed to other modules.

AWS GovCloud (US-West) and AWS GovCloud (US-East) are regions that are specifically designed to host sensitive data and regulated workloads in the cloud, and they are isolated to the US Government's infrastructure. These regions provide a high level of security and compliance.

Examples of the regions include:

• us-gov-east-1

• us-gov-west-1

Reverse Terraform is a feature of Brainboard that allows users to automatically generate Terraform diagrams and code from an existing Terraform file, a public or private repository, and connect to their cloud provider's credentials. This feature enables users to create visual representations of their infrastructure and quickly understand the relationships between resources, as well as generate Terraform code for those resources, making it easier to manage and maintain their infrastructure. Additionally, by connecting to cloud provider credentials, Brainboard can also pull in information about existing resources and use that to generate the Terraform code, allowing users to easily import their existing infrastructure into Terraform.

• Private Repositories (Only GitHub): This fix allows users to connect to their private GitHub repositories and import their Terraform code. This is useful for users who want to keep their infrastructure code private and only accessible to authorized users.
• Supports count, timeouts, depends_on (add connector with the dedicated connector.link.type): This fix enables the tool to support count, timeouts, and depends_on Terraform resources, which are used to create multiple instances of a resource, set timeouts for resources, and specify dependencies between resources. The tool also allows users to add connectors with the dedicated connector.link.type.
• Supports terraform functions (like format, substr, ...), string interpolation (like “aaa$[var.test]”): This fix enables the tool to support Terraform functions, such as format and substr, and string interpolation. Terraform functions are used to perform various operations on strings and variables, while string interpolation allows users to include variables within strings.
• Some resource attributes not parsed: This refers to an issue where some resource attributes were not being parsed correctly by the tool. This fix addresses this issue, ensuring that all resource attributes are parsed correctly.
• Create module idcard on the fly: This fix allows users to create module idcards on the fly. A module idcard is a summary of a module's inputs, outputs, and resources. This allows users to quickly understand the purpose and structure of a module without having to examine its code.
• Import code with module fails: bad source, no version: This refers to an issue where importing code with modules would fail if the source or version was not specified correctly. This fix addresses this issue, allowing users to import code with modules correctly.
• Git root/base repo URL doesn't work: This refers to an issue where the git root or base repo URL was not working correctly. This fix addresses this issue, ensuring that the git root/base repo URL works correctly.
• Support EOF in resource attribute: This fix enables the tool to support EOF in resource attribute. EOF, short for End-of-file, is a control code used to indicate the end of a file or stream. This fix allows the tool to correctly handle EOF in the resource attribute.

Migrate your cloud infrastructure on Brainboard for a better process standardization.