<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Guilherme Sesterheim on Medium]]></title>
        <description><![CDATA[Stories by Guilherme Sesterheim on Medium]]></description>
        <link>https://medium.com/@guisester?source=rss-5b92bb538ec3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*UqhNRHw5TFyu0dWWEN72OA.jpeg</url>
            <title>Stories by Guilherme Sesterheim on Medium</title>
            <link>https://medium.com/@guisester?source=rss-5b92bb538ec3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:05:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@guisester/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Migrating to Substack]]></title>
            <link>https://guisester.medium.com/migrating-to-substack-9c896f87e429?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c896f87e429</guid>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Tue, 05 Aug 2025 18:37:48 GMT</pubDate>
            <atom:updated>2025-08-05T18:37:48.846Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello friends! I&#39;m writing a very quick note over here just to share that I&#39;m migrating into Substack.</p><p>You can subscribe to the new substack page using this link: <a href="https://guisester.substack.com/">https://guisester.substack.com/</a></p><p>Just today I published a new article named <a href="https://guisester.substack.com/p/30-min-downtime-sap-system-refresh">30 min downtime SAP System Refresh. Operating SAP on AWS 2</a> — Hope you enjoy!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c896f87e429" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build SAP Golden AMIs with EC2 Image Builder and Ansible]]></title>
            <link>https://guisester.medium.com/build-sap-golden-amis-with-ec2-image-builder-and-ansible-3ef5849203c1?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ef5849203c1</guid>
            <category><![CDATA[sap-on-aws]]></category>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[golden-ami]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Mon, 28 Jul 2025 13:36:34 GMT</pubDate>
            <atom:updated>2025-07-28T13:36:34.629Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The original content of this post was posted first on the AWS for SAP blog: </em><a href="https://aws.amazon.com/blogs/awsforsap/build-sap-golden-amis-with-ec2-image-builder-and-ansible/"><em>https://aws.amazon.com/blogs/awsforsap/build-sap-golden-amis-with-ec2-image-builder-and-ansible/</em></a></p><h3>Introduction</h3><p>Over the last few years, we’ve been sharing with you how to optimize the operations of your SAP workloads on AWS, using automation, through a series of blog posts. This includes <a href="https://aws.amazon.com/pt/blogs/awsforsap/terraform-your-sap-infrastructure-on-aws/">using Terraform to provision AWS infrastructure for SAP</a>, <a href="https://aws.amazon.com/pt/blogs/awsforsap/automating-sap-hana-installations-on-aws-with-devops/">automating the installation and configuration of your SAP applications</a>, and <a href="https://aws.amazon.com/pt/blogs/awsforsap/automate-high-availability-tests-for-sap-hana/">proving the resiliency of your environment through chaos engineering</a> for SAP HANA. But we were still missing something critical, how to build the golden Amazon Machine Image (AMI) that you use as part of deploying this AWS infrastructure for SAP. So, in this blog post we’ll share how to build a reusable Amazon Machine Image (AMI) to deploy your Amazon Elastic Compute Cloud (EC2) instances, as part of your SAP installation, and provide some sample code for you to get started.</p><p>This approach uses <a href="https://aws.amazon.com/image-builder/">EC2 Image Builder</a> to bake (follow a series of procedures) a brand new AMI ready to receive an SAP installation. The code presented in this blog post supports both Oracle Enterprise Linux (OEL) and RedHat Enterprise Linux (RHEL) subscriptions from AWS Marketplace. The benefits of using this solution are:</p><ol><li>Automated and repeatable process for creating SAP AMIs.</li><li>Simplify staying up to date with updates and security patches.</li><li>Enables an <a href="https://docs.aws.amazon.com/wellarchitected/latest/framework/rel_tracking_change_management_immutable_infrastructure.html">immutable infrastructure approach</a>, which can improve the security, resiliency and consistency of your deployment.</li></ol><p>To help you get started, we’ve shared sample code to automate this process to a <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder">GitHub repository for this automation</a>.</p><h3>The solution</h3><p>This Terraform + Ansible code helps you to create the Golden AMIs for using with your SAP projects. This project creates two Golden AMIs: Red Hat Enterprise Linux (RHEL) and Oracle Enterprise Linux (OEL).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/0*wDrP2P5jwFCFSJMX.png" /></figure><h3>What is configured on the golden AMI</h3><ol><li>Install several packages using YUM: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-install-libs-pkgs-agents/defaults/main.yaml">code</a></li><li>Install AWS CLI: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-install-libs-pkgs-agents/tasks/common/check_aws_cli.yaml">code</a></li><li>Install AWS SAP Data Provider: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-install-libs-pkgs-agents/tasks/rhel/install_data_provider_rhel.yaml">code</a></li><li>Install EFS Utils: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-install-libs-pkgs-agents/tasks/rhel/install_efs_utils.yaml">code</a></li><li>Disable Firewall: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/common/disable_firewall.yaml">code</a></li><li>Set Clock Source: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/common/set_clocksource.yaml">code</a></li><li>Set Timezone: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/common/set_timezone.yaml">code</a></li><li>Set UUIDD: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/common/set_uuidd.yaml">code</a></li><li>Disable core dump, KSM, and SELINUX, enable TSX, Configure user limits for SAP, set general limits, set SAP conf and for tmp files, set tuned: <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/rhel/apply_rhel_specific_changes.yaml">code</a> and <a href="https://github.com/aws-samples/aws-sap-golden-ami-image-builder/blob/main/ansible/golden_amis/roles/role-os-params/tasks/oel/apply_oel_specific_changes.yaml">code</a></li></ol><p>All these configuration steps are listed as pre requisites in <a href="https://docs.aws.amazon.com/sap/latest/sap-hana/configure-operating-system-rhel-for-sap-7.x.html">SAP on AWS Technical Documentation for SAP HANA</a>, <a href="https://docs.aws.amazon.com/sap/latest/general/data-provider-intro.html">AWS Data Provider</a>, <a href="https://docs.aws.amazon.com/sap/latest/sap-hana/std-sap-hana-environment-setup.html">SAP notes listed as RHEL requirements for SAP HANA on AWS</a>, and some <a href="https://docs.aws.amazon.com/sap/latest/sap-netweaver/net-linux-std-resources.html">requirements for SAP NetWeaver as well</a>. It is important to note that actions mentioned on the links that have to happen once the real SAP instance is up, such as setting the hostname, mount EBS and EFS volumes, etc, are not covered in this automation.</p><h3>How to customize your instance configuration using the provided Ansible code</h3><ol><li>Make a copy/fork of this repository into your own one</li></ol><p><em>Want to understand how it works and run the code yourself? Continue reading the original blog post on the SAP on AWS Blog: </em><a href="https://aws.amazon.com/blogs/awsforsap/build-sap-golden-amis-with-ec2-image-builder-and-ansible/"><em>https://aws.amazon.com/blogs/awsforsap/build-sap-golden-amis-with-ec2-image-builder-and-ansible/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ef5849203c1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Operating SAP on AWS 1: Start/Stop]]></title>
            <link>https://guisester.medium.com/operating-sap-on-aws-start-stop-759f6d638ecf?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/759f6d638ecf</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[aws-ssm]]></category>
            <category><![CDATA[devops-for-sap]]></category>
            <category><![CDATA[sap-on-aws]]></category>
            <category><![CDATA[sap]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Tue, 01 Jul 2025 15:16:50 GMT</pubDate>
            <atom:updated>2025-07-08T16:18:44.556Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://www.sap.com/index.html">SAP</a> landscapes are one of the most mission critical workloads every company operates. SAP manages all the critical processes for a company, ranging from purchasing of your raw material, manufacturing, storing, all the way until the sales and distribution, and services/support cycles, passing by HR, controlling, financials, project detailing, and etc. SAP has the biggest credibility in the industry when talking about audits, and results coming from an SAP software are trusted. That&#39;s why most of the S&amp;P 4000 companies use it.</p><p>Now, looking from the day-to-day perspective, <strong>SAP is a stateful monolithic application</strong>, that runs on <a href="https://docs.aws.amazon.com/sap/latest/general/sap-hana-aws-ec2.html">specific</a> <a href="https://docs.aws.amazon.com/sap/latest/general/sap-netweaver-aws-ec2.html">instance types</a> (no containers allowed). (<a href="https://medium.com/@guisester/a-comparison-between-the-typical-sap-s4-hana-and-cloud-native-architectures-fb8149ee80c6">Check this post</a> if you’re interested in knowing more about the architecture and installation of an SAP environment). These characteristics make it very time-consuming for operations handling. SAP operations experts are called <a href="https://community.sap.com/t5/beginner-corner-blog-posts/what-is-sap-basis-the-invisible-backbone-of-sap-explained-for-beginners/ba-p/13591489">SAP Basis</a> professionals.</p><p><strong>SAP operations typically involves 4 main activities</strong> that are performed from time to time, with the frequency varying from the industry your company is in. <strong>The 4 activities are: Start/Stop, Scaling, System Refresh (also called System Copy), and OS/App/DB patching/upgrading. On this post we&#39;re approaching the orchestration of the Start/Stop operation.</strong></p><h3>Start/Stop</h3><p>Start/Stop, as the name says, is the action of starting or stopping an SAP application (I&#39;ll use the word application to reference both the application and database layers). Whenever we stop an SAP environment we&#39;re creating downtime. And, since SAP is mission-critical, we always want the least downtime possible.</p><p><strong>Start/Stop is achieved using the below commands:</strong></p><blockquote>sapcontrol -nr 00 -function Start</blockquote><blockquote>sapcontrol -nr 00 -function Stop</blockquote><p>Where:</p><ul><li><strong>sapcontrol</strong> — the default SAP cli. Available across all of the SAP NetWeaver or HANA-based applications.</li><li><strong>-nr</strong> — system number is a concept used by SAP to differentiate multiple applications running on the same instance. It cascades all the way to the network ports a specific installation will be exposing.</li><li><strong>-function</strong> — the operation you want to perform on that application. There are variations such as StopWait (which performs a soft shutdown), StartWait (which waits for the start command to be completed), StartSystem, and StopSystem (which allows you to cover more than one application running on the same instance).</li></ul><p>Start/Stop typically are used for maintenance activities. Changes required to servers, resizing data volumes, patching instances, upgrading software, installing additional software or agents like monitoring, and etc.</p><h3>When it gets complex</h3><p>Start/Stop is straightforward and uncommon to fail. The more complex your SAP environment is, the more complex the operation will get. SAP landscapes&#39; <a href="https://guisester.medium.com/a-comparison-between-the-typical-sap-s4-hana-and-cloud-native-architectures-fb8149ee80c6">basic architecture</a> will require Start/Stop to be done in three waves:</p><ul><li><strong>When stopping:</strong> first stop the application servers, then <a href="https://help.sap.com/docs/SLTOOLSET/977b323808d0440a9c9fc9bed19a0861/e8d3747e5f5248588443e5b1ea0d3a35.html?version=CURRENT_VERSION_SWPM20">ASCS and ERS</a>, and finally the databases.</li><li><strong>When starting it&#39;s the opposite:</strong> first start the databases, then ASCS and ERS, and then the application servers.</li></ul><p>The complexity will be influenced by some factors:</p><ul><li><strong>The number of instances and applications you have installed:</strong> if you have a simple HA environment with 6 servers it&#39;s already a stretch but still manageable that someone will login to each of those servers and run the <em>sapcontrol</em> commands. But considering most of the environments will have a bigger number of application servers (some having more than a hundred), you&#39;ll have to have some automation in place to save time.</li><li><strong>The different types of applications installed:</strong> some SAP components depend on the three default ones to run. A common example of this is <a href="https://help.sap.com/docs/SAP_NETWEAVER_700/129ff87c6c5310149786f918efe32a65/a4929d4206b70931e10000000a1550b0.html">SAP TREX</a>, which depends on the application servers. So, when TREX is in the picture, you have one more layer to start/stop, making it now: DBs, ASCS/ERS, App Servers and TREX.</li><li><strong>Third-party applications:</strong> since SAP keeps the core business data, every installation will have integration with third-party tools or custom software. These third-party tools have to either be stopped and started as well, or they have to account for the expected downtime and implement some sort of self-healing/retrying mechanism for the requests that are going to fail while SAP is down.</li></ul><p>Now, considering you have some automation in place operating your fleet of 100+ SAP servers (<strong>the automation to start or stop them all will take some 20~30 min to run if well designed</strong>), if one of the Stop commands fail on the 50th server of your order, do we abort the entire execution for someone to check why that one failed? Or do we go ahead and acknowledge the risk of corrupting one small piece of the big puzzle?</p><p>Failures from the Start/Stop commands themselves are unusual, but overall failures come from different sources, especially if you allow human intervention in your servers:</p><ul><li>Network changes</li><li>Hosts changes</li><li>Disks/Volume mount changes</li></ul><h3><strong>Conclusion</strong></h3><p>Due to SAP&#39;s architecture, it&#39;s not safe to just go to the AWS console, and stop or start the instances straight. And depending on how complex your environment is, you&#39;ll require a massive number of people who specializes in different components of your landscape to execute and monitor the operation. Most of that can be sped up by a well designed automation, and save precious minutes or hours of business downtime.</p><p>AWS offers a wide range of ways to achieve Start/Stop: <a href="https://docs.aws.amazon.com/ssm-sap/latest/userguide/stop-sap-application.html">SSM for SAP</a>, <a href="https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-sap-automation/system-start.html">simpler SSM docs</a>, <a href="https://aws.amazon.com/blogs/awsforsap/automate-start-or-stop-of-distributed-sap-hana-systems-using-aws-systems-manager/">customized and broader solutions</a>, and even <a href="https://aws.amazon.com/blogs/awsforsap/start-stop-sap-systems-with-slack-using-aws-chatbot/">using Slack</a>.</p><p>Start/Stop is a dependency for all the other operations described above, so having a mature process for it, that won&#39;t bring surprises, will make all of the rest easier to be accomplished.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=759f6d638ecf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automate High Availability Tests for SAP HANA]]></title>
            <link>https://guisester.medium.com/the-original-content-of-this-post-was-posted-first-on-the-aws-for-sap-blog-https-aws-amazon-com-b-4c140d8bfefc?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c140d8bfefc</guid>
            <category><![CDATA[chaos-engineering]]></category>
            <category><![CDATA[sap-on-aws]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[sap]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Tue, 17 Jun 2025 15:31:38 GMT</pubDate>
            <atom:updated>2025-07-03T13:17:09.464Z</atom:updated>
            <content:encoded><![CDATA[<p>The original content of this post was posted first on the AWS for SAP blog: <a href="https://aws.amazon.com/blogs/awsforsap/automate-high-availability-tests-for-sap-hana/">https://aws.amazon.com/blogs/awsforsap/automate-high-availability-tests-for-sap-hana/</a></p><h3>Introduction</h3><p>The software development and operations industry has been modernizing and increasingly, applying DevOps as the standard approach to its processes. However, SAP installation and operations still tend to be very much manually driven. To help evolve this to an automated approach, we’ve demonstrated in our <a href="https://aws.amazon.com/pt/blogs/awsforsap/terraform-your-sap-infrastructure-on-aws/">first blog post</a> how to provision the infrastructure for SAP applications using Terraform and native AWS tools like AWS Launch Wizard. Then the <a href="https://aws.amazon.com/blogs/awsforsap/automating-sap-hana-installations-on-aws-with-devops/">second blog post</a> showed the automation of SAP software installation using Systems Manager. And finally, the <a href="https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/">third blog post</a> went deeper on the automation and performed an end-to-end installation for a full SAP landscape operating in High Availability (HA).</p><p><strong>This blog post focuses more on the operations of an SAP landscape. High availability testing is required to understand the resiliency of your applications and to ensure that the deployed applications meet the Recovery Time Objective.</strong> Many organizations have to test their high availability configuration from time to time to stay compliant with auditing processes as well.</p><p>The solution detailed in this blog has come from the work the AWS SAP Professional Services team has undertaken with a number of customers to automate the deployment and testing of High Availability clusters for SAP HANA workloads, which we are providing as open source (links below) for customers to use and adapt as required.</p><p>With this blog post we’re introducing an industry-wide practice known as <a href="https://en.wikipedia.org/wiki/Chaos_engineering">chaos engineering</a> into the SAP world. It will give you more confidence and more predictability on how your SAP landscape behaves, and also how you can configure it to self-heal after an outage or critical errors.</p><p><strong>While applying chaos engineering can improve the resiliency of your SAP landscape</strong> by identifying potential problems before they cause an issue, <strong>from our experience, manually running the required set of test scenarios can take up to two months in elapsed time and requires a highly skilled professional in most organizations.</strong> In this blog post, we will share sample code that you can use as a starting point to automate these test scenarios, save significant amounts of time for your team, and stay compliant with auditing processes.</p><p>The benefits brought by this solution, when compared to the typical manual approach, for testing HA configuration are as follows:</p><ol><li><strong>Speed:</strong> from about 2 months to hours.</li><li><strong>Reliability:</strong> covers 12 HA testing scenarios (described below) in a repeatable process.</li><li><strong>Reduce human errors:</strong> since the HA test is turned into a repeatable process, it reduces potential failure rate of the tests from human error.</li><li><strong>Audit asset:</strong> the final HTML report generated by this solution has all the common information required in audit assets.</li><li><strong>Improvement asset:</strong> when there’s an error, the final HTML report also highlights what specifically went wrong during the test, and gives a full picture of how was the system before and after the error. This then is handled to an SAP BASIS professional for the fixes on the high availability configuration to be applied.</li></ol><p>The solution presented here has some different ways to run. But in the end they all will generate an HTML report as the example shown on section “The report”.</p><p>For you to use this solution as a starting point, there’s a <a href="https://github.com/aws-samples/automate-sap-hana-high-availability-test">public GitHub repository</a> with all the code required. For understanding how to run it, go to section “How to Run“. A quick lab environment can be spun up using <a href="https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/">this guide</a>. This sample code is to be used as a starting point to reduce the efforts required to automate the HA testing at your company. This sample code is built and tested for running on SAP HANA 1909 on RedHat OS (Operating System).</p><h3>Prerequisites</h3><p>You need the following prerequisites before starting this guide and running this code:</p><ol><li><a href="https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html">Install Ansible</a> on your controller instance. The controller instance can be:</li></ol><ul><li>Your own instance/laptop/workstation</li><li>Your CI/CD tool to automate the run of this solution</li><li>Ansible Tower</li></ul><p>2. SSH access and connectivity established between the controller instance and the SAP landscape instances that you want to run the HA tests on.</p><p>3. One SAP landscape comprised of:</p><ul><li>Two HANA instances with HA previously configured. Refer to the AWS documentation on <a href="https://docs.aws.amazon.com/sap/latest/sap-hana/sap-hana-on-aws-ha-cluster-configuration-on-rhel.html">configuring Red Hat Enterprise Linux clusters for SAP on AWS</a> for more information.</li><li>One ASCS instance</li><li>One PAS instance</li></ul><p>4. One AWS IAM Role with the following permissions configured on your AWS CLI (Command Line Interface). This role has to be configured on the AWS cli on the controller instance. Ansible will use it to interact with your SAP landscape during the tests. You can check <a href="https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html">how to configure an additional profile for your AWS CLI</a> for more information:</p><ul><li>ec2:StartInstances on all instances</li><li>ec2:RebootInstances on all instances</li><li>ec2:StopInstances on all instances</li></ul><p>5. Create an AMI and capture snapshots of each of the EBS volumes from the instances you’re involving in this scenario as a backup.</p><h3>Covered high availability test scenarios</h3><p>For each test scenario, one goal is for them to be useful as standalone tests, in case you don’t want to run all the tests at once. To accomplish this, we have certain tasks that are executed before and after the test scenario, to confirm that the environment has a valid configuration, and the test has completed successfully. These common steps are as follows, shown in the sequence of execution:</p><ul><li>Were all the required input parameters informed for it to run?</li><li>Is there connectivity between the nodes and the controller node?</li><li>Which node is Primary and which is Secondary?</li><li>Is a minimum high availability configuration in place?</li><li>Is the replication mode set on HANA the same before and after failover?</li><li>What is the ASCS enqueue number before the test start? Does it match with the number after failover?</li><li>Is PAS connected to the right Database instance? Before and after failover?</li></ul><p>The test scenarios available in the GitHub repository are as follows:</p><ol><li>“HDB Stop” on Primary database.</li><li>“HDB Stop” on new Primary database (after failover).</li><li>“HDB Stop” on Secondary database.</li><li>“PCS node standby” on Primary database.</li><li>“PCS node standby” on new Primary database (after failover).</li><li>“kill -9 pid” on Primary database.</li><li>Crash instance with “echo ‘b’ &gt; /proc/sysrq-trigger” on Primary database.</li><li>Crash instance with “echo ‘b’ &gt; /proc/sysrq-trigger” on new Primary database (after failover).</li><li>“HDB kill -9” on Primary database.</li><li>“HDB kill -9” on new Primary database (after failover).</li><li>Reboot Primary database.</li><li>Reboot new Primary database (after failover).</li></ol><h3>The report</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BgFm3i0gu5jtCuYQ.png" /></figure><p>Image 1 — Example of HTML report generated with a failure on the last step</p><p><strong>Want to understand how it works and run the code yourself? Check out the original blog post on the SAP on AWS Blog: The original content of this post was posted first on the AWS for SAP blog: </strong><a href="https://aws.amazon.com/blogs/awsforsap/automate-high-availability-tests-for-sap-hana/"><strong>https://aws.amazon.com/blogs/awsforsap/automate-high-availability-tests-for-sap-hana/</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c140d8bfefc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is DevOps for ABAP a thing?]]></title>
            <link>https://guisester.medium.com/is-devops-for-abap-a-thing-db759f9e1779?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/db759f9e1779</guid>
            <category><![CDATA[sap-on-aws]]></category>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[abap]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Mon, 02 Jun 2025 14:00:09 GMT</pubDate>
            <atom:updated>2025-06-02T14:00:09.564Z</atom:updated>
            <content:encoded><![CDATA[<p>While most of the <a href="https://aws.amazon.com/devops/what-is-devops/">DevOps</a> movement, practices and concepts emerged <a href="https://devopsdays.org/about">between 2007 and 2009 with the Devopsdays</a>, and brought huge improvements for the software development lifecycle, a big question mark is still floating above the ABAP development. What can we do in terms of DevOps for SAP? Can we harness the benefits of regular DevOps practices? In this blog post I&#39;m addressing what you should and should not expect from DevOps in an SAP environment.</p><p>For doing so, I&#39;m separating the content into a few blog posts. This one fully addresses the DevOps concept for ABAP and a few other software development practices <strong>inside</strong> SAP. And in a few future blog posts I&#39;ll address what can be made in terms of DevOps <strong>around</strong> SAP.</p><p>For DevOps <strong>inside</strong> SAP, there are three different stacks to approach: <strong>1) SAP ABAP on ECC development, 2) Fiori and ABAP Development on S4/HANA, and 3) BTP Development.</strong></p><p>To simplify the comparison, we&#39;ll cover them looking for some key common components of a DevOps pipeline:</p><ol><li>Pipelines (do we have them?)</li><li>Automated testing (unit and integration)</li><li>Code scanning</li><li>Blue/Green and/or Canary strategies supported</li></ol><h3><strong>Stack 1 — SAP ABAP on ECC</strong></h3><p>This is the oldest way of developing ABAP applications and doesn&#39;t allow the most important practices when talking about DevOps. The flow is very simple:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*uANUIYuPxdvUmp6Mbcmv_A.png" /><figcaption>ABAP Development for ECC</figcaption></figure><p>On the left, developers will develop the code inside one of the Application Servers, and TMS (<a href="https://www.sap.com/products/scm/transportation-logistics.html?campaigncode=crm-ya22-int-1517076&amp;source=ppc-1na-googleads-search-71700000111981630-58700008460615646-smc_dss-x-x-x&amp;gad_source=1&amp;gad_campaignid=20325011188&amp;gbraid=0AAAAAp1XXM3rxmlG6shdNrzCKLBxX9CNG&amp;gclid=Cj0KCQjwlYHBBhD9ARIsALRu09pyjzt6XPwV5HikeT6sHltGPOduMdNXmQlKvNoD-4nl90wS3V23MLAaAmsaEALw_wcB&amp;gclsrc=aw.ds">Transport Management System</a>) takes care of saving the code to the database and promoting it between environments. In this scenario there is no official support for Git. A few highlights:</p><ul><li>Code is stored on the database</li><li>Doesn&#39;t work with <a href="https://help.sap.com/docs/ABAP_PLATFORM_NEW/4a368c163b08418890a406d413933ba7/f319b168e87e42149e25e13c08d002b9.html">gCTS</a> (more on gCTS on stack 2)</li><li>No mature DevOps capabilities like deployment strategies, code scanning, etc.</li></ul><p>In case DevOps is a must for your environment and you&#39;re open to some risk, there is <a href="https://abapgit.org/">abapGit</a>, <strong>which is</strong> <strong>not supported by SAP</strong>, and is a community-drive alternative so you can use Git for development inside ECC.</p><p>On this scenario you can create automated tests, but you won&#39;t have a pipeline to run them automatically at every deployment.</p><h3>Stack 2 — SAP S4/HANA with Fiori</h3><p>When we have S4/HANA to work with, a few new possibilities open up. In this stack we&#39;re adding <a href="https://www.sap.com/products/technology-platform/fiori.html">SAP Fiori</a> as a component to our frontend. Fiori was created to give more flexibility to frontend applications and is much newer than SAP core. Fiori allows the creation of web and mobile apps, providing the UX required by modern applications. So let&#39;s take a look at the two flows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ydFjJLqsXLe7TjLulE9Czg.png" /><figcaption>Different pipeline approaches for frontend and backend</figcaption></figure><p>For the frontend development, now we are talking about Javascript-based coding and not ABAP. With Fiori, you can have a pipeline automating your unit, integration and e2e tests, scanning the code and plugging in even Selenium/Jasmine for more mature tests.</p><p>For the backend part there&#39;s a new component called <a href="https://help.sap.com/docs/ABAP_PLATFORM_NEW/4a368c163b08418890a406d413933ba7/f319b168e87e42149e25e13c08d002b9.html">gCTS</a>. gCTS allows us to develop outside an SAP Application Server, and therefore storing our code on a Git-based platform, creating pipelines and scanning the code automatically with tools like <a href="https://docs.sonarsource.com/sonarqube-server/latest/analyzing-source-code/languages/abap/">Sonarqube</a>. Still, no mature deployment strategies are supported or layers of automated tests.</p><h3>Stack 3 — SAP BTP</h3><p><a href="https://www.sap.com/products/technology-platform.html?campaigncode=crm-ya22-int-1517065&amp;source=ppc-1na-googleads-search-71700000111878744-58700008462631428-btp_bts-x-x-x&amp;gad_source=1&amp;gad_campaignid=20324908708&amp;gbraid=0AAAAAp1XiZjHJmS9vn1CiS31i8h4Hy4Dw&amp;gclid=Cj0KCQjwlYHBBhD9ARIsALRu09qQGptuVu8WKHrODdsEFSqc5Ir1ydDWKBDMWqSWsBS41hgXAGPv-b4aAp1YEALw_wcB&amp;gclsrc=aw.ds">SAP BTP</a> is the latest investment of SAP on modernizing the software development on its environments. With BTP, SAP keeps a clean core running, which we don&#39;t have access anymore (as opposed to ECC), and provides a layer of functions (similar to microservices) which can be used during software development to customize behaviors and provide integrations. Let&#39;s take a look at the new flow:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hMk7BLccKpv6piJhkVjKRA.png" /><figcaption>Development flow using SAP BTP for the backend</figcaption></figure><p>On the frontend using Fiori, there are no changes from the second stack. Now, on the backend flow we have the new capabilities common to modern software development. You can run all the pipelines inside the BTP platform as shown above, but <a href="https://help.sap.com/docs/continuous-integration-and-delivery/sap-continuous-integration-and-delivery/using-api?language=en-US">BTP also provides APIs</a> for integrating with third party apps such as Jenkins. On this third stack, <a href="https://help.sap.com/docs/btp/sap-business-technology-platform/blue-green-deployment-strategy">Blue/Green deployment</a> is available for the backend as well.</p><h3>The comparison</h3><p>Putting all the stacks together and going straight to the point, the table below shows all the stacks and tells us whether each benefit of DevOps can be used:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EOnrgPx19m5090sGlUJgSw.png" /></figure><p>Harnessing the benefits of DevOps is a long journey when we talk about software development <strong>inside</strong> SAP. The next blog posts are going to approach the DevOps practices that can be achieveed when we look at the infrastructure layer only, and apply it <strong>around</strong> SAP.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db759f9e1779" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automating SAP installation with open-source tools]]></title>
            <link>https://guisester.medium.com/automating-sap-installation-with-open-source-tools-283e94df7970?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/283e94df7970</guid>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops-for-sap]]></category>
            <category><![CDATA[sap-on-aws]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Tue, 20 May 2025 15:36:43 GMT</pubDate>
            <atom:updated>2025-05-20T15:36:43.579Z</atom:updated>
            <content:encoded><![CDATA[<p>The original content of this post was posted first on the AWS for SAP blog: <a href="https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/">https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/</a></p><h3>Introduction</h3><p>We’ve already demonstrated in <a href="https://aws.amazon.com/pt/blogs/awsforsap/terraform-your-sap-infrastructure-on-aws/">our first blog post</a> how to provision the infrastructure for SAP applications using Terraform, and in <a href="https://aws.amazon.com/pt/blogs/awsforsap/automating-sap-hana-installations-on-aws-with-devops/">our second blog post</a> we added in automation of SAP software installation using Systems Manager. Now it is time to go deeper with open-source common tools like Jenkins and Ansible to have the SAP installation in a comprehensible single pipeline. This approach brings a few benefits added on top of the other alternatives:</p><ol><li>Helps customer teams to be compliant with auditable policies related to configuration as code, since in this blog post we will automate all of SAP software installation.</li><li>Turns the SAP installation into a repeatable process, making the quality of the outcome easier to improve, since it can be simulated and run several times using the same source of information.</li></ol><p>Another good option to deploy SAP is <a href="https://aws.amazon.com/pt/launchwizard/">AWS Launch Wizard</a>. Customer teams can build SAP systems that align with AWS best practices rapidly from the AWS Console following a guided experience designed for SAP administrators.</p><p>To help achieve goals such as increasing deployment efficiency and quality, many customers are automating as many repeatable processes as they can. Jenkins is an industry pattern providing one orchestrator environment that helps to put together all the required pieces. It runs the same commands we’d do manually using BASH for Linux.</p><p>In the end of this article you’ll have a Jenkins pipeline with the image below as its outcome:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*wd64nPYH-DOPOEyw.png" /></figure><p>The above pipeline has capabilities to build all the needed infrastructure and install the actual software for non-HA (1) SAP Primary Application Server (PAS), SAP Hana Database and SAP ABAP SAP Central Services (ASCS).</p><p>To help you make use of Jenkins and Ansible to fully automate your SAP software installation, we’ve open sourced code to a <a href="https://github.com/aws-samples/aws-install-sap-with-jenkins-ansible">GitHub repository for this installation automation</a>. This will automate and will be used together with the GitHub repository we created for provisioning your infrastructure using, which was explained in our first blog post.</p><h3>Understanding the pipeline steps</h3><ol><li>Checkout SCM — this is when Jenkins looks for the code on GitHub</li><li>Prepare — Jenkins checks if all the required variables for the run are present (variables are described on section “Preparing Jenkins”)</li><li>Check ENV states — checks if there is one S3 bucket available for storing the final Terraform state file, and also if there’s already one environment up using this automation. IMPORTANT: this step is going to create on bucket on your provided account. The bucket name will be “sap-install-bucket-” followed by a random number. Terraform will store its state file in this bucket.</li><li>Create ENV — The infrastructure automation based on Terraform creates all the needed infrastructure for this installation. To understand what’s going to be created, review our first blog post.</li><li>Install Hana and ASCS — this is a place holder, meaning that the next two steps (6 and 7) run in parallel.</li><li>Install Hana — installs Hana on the instance created by Terraform.</li><li>Install ASCS — Installs ASCS on its instance.</li><li>Install PAS — installs PAS on its dedicated instance after Hana and ASCS are finished.</li><li>Notify — a simple terminal notification stating the end of processing.</li><li>Post actions — Jenkins auto-generated step stating the end of the whole pipeline.</li></ol><h4>Want to understand how it works and run the code yourself? Check out the original blog post on the SAP on AWS Blog: The original content of this post was posted first on the AWS for SAP blog: <a href="https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/">https://aws.amazon.com/blogs/awsforsap/automating-sap-installation-with-open-source-tools/</a></h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=283e94df7970" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A comparison between the typical SAP S4/HANA and cloud-native architectures]]></title>
            <link>https://guisester.medium.com/a-comparison-between-the-typical-sap-s4-hana-and-cloud-native-architectures-fb8149ee80c6?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb8149ee80c6</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[sap-on-aws]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Sun, 04 May 2025 20:09:04 GMT</pubDate>
            <atom:updated>2025-05-04T20:09:04.114Z</atom:updated>
            <content:encoded><![CDATA[<p><a href="https://www.sap.com/index.html">SAP SE’s</a> software manages critical business processes for many global organizations, including finance, sales, distribution, materials, warehousing, human resources, etc. <a href="https://www.sap.com/investors/en/financial-news/ad-hoc-news/2020/04/1942377.html">77% percent of global transaction</a> revenue flows through <a href="https://www.sap.com/about/what-is-sap.html">SAP systems</a>. Most of the public listed companies are SAP customers due to how friendly the software is for the audits required. And <a href="https://www.sap.com/documents/2017/04/4666ecdd-b67c-0010-82c7-eda71af511fa.html">98 of the 100 largest companies in the world are SAP customers</a>.</p><p>Given these credentials, we can easily assume that SAP has a vital importance for most of the companies we interact with. It is extremely reliable and once stable, doesn&#39;t require constant interaction to ensure it&#39;s working properly. Due to how critical the software is, SAP typically has been risk-averse in terms of adopting new technologies and practices for its main platform, but mostly for evolving its architecture. And while the open-source world evolved at a rapid pace, the SAP core has remained unchanged for a long while.</p><p>Let&#39;s take a look at typical architectures, both of SAP and of a cloud-native micro-services application, and highlight a few of the most important differences and their consequences for the business running on it.</p><h3>SAP Architecture</h3><p>The SAP architecture is very similar to what is known in the software industry as a <a href="https://en.wikipedia.org/wiki/Monolithic_application">monolith</a>. Let&#39;s take a look at the SAP architecture and analyze its core components, as well as its operation details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1007/1*MUrF3vTCs3GX-3lrmBOJ_A.png" /><figcaption>Typical SAP S4/HANA architecture</figcaption></figure><p><strong>The components - </strong><a href="https://help.sap.com/docs/SLTOOLSET/977b323808d0440a9c9fc9bed19a0861/e55194861f5c48649e6991420ba5cf50.html?version=CURRENT_VERSION_SWPM20"><strong>and more details</strong></a><strong>:</strong></p><ul><li>SAP HANA Primary — active database.</li><li>SAP HANA Secondary — standby-database.</li><li>SAP ASCS (ABAP Central Services) — works as a message server in the architecture.</li><li>SAP ERS (Enqueue Replication Server) — is the HA component for ASCS. Takes over if ASCS fails.</li><li>AS (Application Server) 1, 2, 3, N — this is where users connect to.</li></ul><p><strong>Important remarks:</strong></p><ul><li>An SAP environment is very reliable and hardly requires intervention during regular operation.</li><li>The typical required operations for the environment are patching the Operating System (OS) and the SAP software themselves. This does require to stop the entire environment and bring it back once the patches are completed.</li><li>It is common to prepare and fine-tune some parameters when there&#39;s a large-scale event happening, such as a black Friday or a major public product announcement.</li><li>When logging in, users reach out to ASCS, which assigns an application server considering the load across all the Application Servers. Once assigned to a server, all the user requests are processed by that same server, making it a stateful application.</li><li><a href="https://help.sap.com/docs/SAP_HANA_PLATFORM/52715f71adba4aaeb480d946c742d1f6/c39e5936ab9240a28cc85e1086315737.html">SAP HANA is an in-memory database</a>. Usually it requires instances with TBs of memory, demanding the <a href="https://aws.amazon.com/ec2/instance-types/high-memory/">U family</a> or the <a href="https://aws.amazon.com/ec2/instance-types/">X family</a> on EC2.</li><li>SAP does not run on containers. So all the components run on EC2 instances.</li><li>You cannot customize the S4/HANA stack. You can&#39;t change the code used for building the Application Server, ASCS or the HANA DB, as they are proprietary from SAP.</li><li>The pipelines for deploying this environment are going to be conceptually very simple: infrastructure layer and application installation.</li><li>Regular cloud-native autoscaling is not supported for out-of-the-box SAP installations.</li></ul><h3>Cloud-native micro-services Architecture</h3><p>Now, let&#39;s take a look at a high-level cloud-native architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FM2Kamq6ZXrGybFFj9oUTw.png" /><figcaption>Simple micro services architecture</figcaption></figure><p><strong>The components:</strong></p><ul><li>MS (MicroService) X DB — Database available in one availability zone.</li><li>Read replicas and/or standby databases available in the other availability zones.</li><li>Application Load Balancer — directs users to the best available pod at the moment, regardless of where the last request was sent into, making it a stateless application.</li><li>Pods running on some sort of Kubernetes represent the application layer.</li><li>Important: this simple approach doesn’t show any messaging/queue server, cache layer for the database, in-memory databases and other components that could make the architecture more complex.</li></ul><p><strong>Important remarks:</strong></p><ul><li>A micro services architecture by design is made for constant change. And since everything in this architecture is customizable, it is expected that the environment operates under some level of expected failure.</li><li>When patching any layer of the architecture, it is possible to prevent any downtime.</li><li>It&#39;s fairly expected that this application will use small instances, that are going to be cheaper than the aforementioned U or X family.</li><li>Given the flexibility of containers, modern deployment strategies can be applied to the application layer, such as Blue/Green and Canary.</li><li>The pipelines are going to be quite complex in this scenario, depending on how stable the environment has to be, and there will be quite a few: a few for the common infrastructure and SaaS configuration, at least one for each application deployment. Steps in these pipelines will include different layers of testing, deployment strategies, and etc.</li><li>You can and it&#39;s very simple to autoscale the application following traffic demands.</li></ul><h3>The comparison</h3><p>Looking from the business side, both architectures will be invaluable for corporations. SAP brings the stability of a renowned software, while the micro services architecture allows companies to create the tailored experience their customers demand. Them both work side by side. Having that in mind I want to highlight some key differences that will help to understand when one is required versus the other:</p><ol><li><strong>Time to deploy/investment</strong> — SAP is much faster to deploy than to create a micro services architecture in the cloud.</li><li><strong>Stability — </strong>SAP is and has been extremely reliable for decades. On a micro services architecture you have to expect some instability while the software is maturing.</li><li><strong>Downtime — </strong>In mature organizations, the downtime required for the maintenance of an SAP landscape is going to be acceptable (2 ~ 12h) for a software as stable and critical as it is. But, there&#39;s still downtime. In a micro services architecture, you can expect to have no downtime.</li><li><strong>Flexibility</strong> — In a micro services architecture, since every layer of the application is built/<em>crafted</em>, it&#39;s highly flexible and customizable from day one. On SAP, there&#39;s no customization allowed on the infrastructure side or the components that run the application. So, adopting some new technology to make the environment run faster/smoother/easier to manage, is not an option for SAP.</li><li><strong>Autoscaling</strong> — Since micro services are very friendly to be run in the cloud, these applications can benefit from the pay-as-you-go model, fine tuning the application behavior to save money during low-utilization periods. On SAP, you will size the architecture once and will pay for that same amount of hardware for the whole month without any optimizations.</li></ol><h3><strong>Conclusion</strong></h3><p>In this blog post I&#39;m presenting the differences for both SAP natives and open source/micro services native decision makers, who want to take a look at how the other side of the wall works. Understanding the differences helps to understand why/how some decisions are made on each environment, such as investment size, preparation for large scale events, downtime situations, and etc.</p><p><em>PS 1:</em> Even though I mentioned application pipelines for the micro services architecture, blue/green, canary and etc, I didn’t mention the software development inside of an SAP environment using the ABAP programming language. This is the subject for a future blog post.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb8149ee80c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Are you a micromanager?]]></title>
            <link>https://guisester.medium.com/are-you-a-micromanager-3780db42e6f0?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/3780db42e6f0</guid>
            <category><![CDATA[relationships]]></category>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[psychology]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[management]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Sun, 18 Aug 2024 16:29:52 GMT</pubDate>
            <atom:updated>2024-08-18T16:29:52.179Z</atom:updated>
            <content:encoded><![CDATA[<p>Micromanaging is not new when discussing leadership and the different styles to it. Micromanagers often have good intentions, but they usually forget or don’t have a full grasp of their impact in their team.</p><p>Great leaders share their final goals, provide guidelines, give space and then get back to check on the results. Micromanagers are on the opposite side, being picky about small decisions, and bugging more than helping. One additional dangerous trait is trying to be perfectionist and trying to address every possible issue a project can face. Besides being impossible, it darkens the mood of a project by bringing the sense that there’s always something being missed. The opposite and much better scenario is of course being diligent about tasks, and if something is missed, to have accountability and address it openly.</p><p>Requirements and variables change all the time, and since we just can’t forecast them, it’s better to go with it and get comfortable with all the change.</p><p>The same things that change all the time also take time to mature, and it’s unrealistic to assume that big and important projects will come out flawless from the very beginning. There are several strategies to mature changes before they are live, but today we’re talking about micromanagers only.</p><h3>How to spot a micromanager</h3><p>One usually isn’t aware they are a micromanager. Most of the times they feel pressed for certain accomplishment and fail on handling the pressure, passing it in the wrong way to their teams.</p><p>Micromanagers often think they are ensuring quality or some portion of success by taking a look at every detailed outcome – but in fact they are forgetting the big picture and being picky about small decisions – high quality is attained by having good people in the right positions, coaching them, and constantly raising the bar and providing them trainings so they can perform better. That same good people have to be motivated, and when the right time comes they will push that extra mile to ensure the success of a project.</p><p>If you are suspecting you are a micromanager, I also suggest you start taking notes and comparing how many times people get to the very specifics of your work versus the number of times you get to details of other people’s work. And if you have somebody nitpicking your work, there’s a high change you’re being micromanaged as well.</p><h3>The effects of having a micromanager around</h3><p>Micromanagers are a big blocker for any organization success, so let’s clarify how they impact the people they interact with.</p><p><strong>Lack of trust and commitment</strong>: because of the constant revisions and sometimes pointless changes required, if your team stays around, they’ll lose trust in you. Having one’s work constantly unraveled creates an insecure sentiment across the team, because people can’t predict when the auditor of small items is showing up again. And a consequence of that is the lack of commitment. When we focus too much on small stuff, the sight of the big picture fades away, and we forget why we’re doing what. People have to have a clear point of view about the big picture goals, this is one of the basics for motivation at work.</p><p><strong>Lower quality outcome</strong>: if you have a senior team comprised of you and 2 or more people, it’s already humanly impossible for one folk to know more than other two. If those people were hired it means they have something to bring to the table. So if you assume you know better than their decisions and keep asking for revisions for things to be done <em>your way</em> (like cosmetic changes or different points of view), you’re imploding their quality. Soon they’ll start thinking “why am I stretching/researching/improving for this task? My manager will have me redo it either way”. This way you loose the potential of three (you and your two folks) thinkers, and is reducing to just one thinker.</p><p><strong>Bureaucracy</strong>: the easiest way to spot a micromanager is the excessive documentation. Documentation is good and very helpful. And there’s a thick line separating useful documentation from useless registers. A good strategy to apply is to think about the documentation you’re going to write: is this doc being read in the next few months or so? If not, is there a person’s routine getting benefit from this new doc? If you have a no for both of the questions, or you know that document is being written “just in case” we need to show somebody why we took a certain decision, this is bureaucracy.</p><p><strong>Lower performance</strong>: a basics of micromanaging is that you review everyone’s work in your team. If you have to look after and check boxes for everyone, you’ll burnout eventually, and the work of your entire team has to go through your funnel, creating one single lane for shipping work out. And instead of having a strong team supporting you and taking initiatives, you end up babysitting them and reducing their capacity.</p><h3>Act now</h3><p>Remember: an important factor for people development is making mistakes. Of course if a manager sees a relevant one, they’ll stop it as this is their role. But giving space for people to learn by themselves is the only way to achieve peace of mind and a team that trusts you.</p><p>So the next time you hear a dry “sure” after asking for the fifth revision of something, I encourage you to take a step back and think through it with time to understand what that means and how your team perceives you in the long run.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3780db42e6f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop being a mutt dog and be a senior]]></title>
            <link>https://guisester.medium.com/stop-being-a-mutt-dog-and-be-a-senior-405c9aba0b52?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/405c9aba0b52</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[healthy-work-environment]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Wed, 05 Jun 2024 13:04:18 GMT</pubDate>
            <atom:updated>2024-06-05T13:04:18.507Z</atom:updated>
            <content:encoded><![CDATA[<p>In Brazilian portuguese there’s a popular expression: the <em>mutt dog syndrome</em>. It happens when one automatically feels they are less than the other person without actually grasping their knowledge around a given subject. Fear is what drives the syndrome. It’s not a paralizing fear, but being afraid of messing something, or having your contribution denied/mocked on, already counts as fear.</p><p>What&#39;s the difference between a junior, a staff and a senior engineer?</p><ul><li>The junior is a beginner. They will need assistance for doing their tasks, and some oversight until they can be independent.</li><li>The staff engineer is already aware of the technical part. And for the things they don’t know, they are comfortable looking for a solution, testing and shipping themselves. He can take care of himself and won&#39;t need any handholding for any technical subject.</li><li>Now the senior accumulates the technical knowledge, but is also the person responsible for the team&#39;s work environment. The senior fosters a good relationship for everyone to work, fosters collaboration, eliminates noises, wacky competition, and brings things back on track when they go south (by the way I know a lot of engineers who say they are senior, but are too proud to offer help and to teach. You got to have a good amount of humility to be a true senior, and pride is your number one enemy).</li></ul><p>It takes courage for moving from a staff engineer to a senior one. And that typically comes with experience. The more experience you have, the more comfortable you&#39;ll be on your job, simply because you already know some of the bad outcomes that can come from a given scenario, and you&#39;ll be prepared to handle them when they come. That courage is the result of confronting the fear present in the syndrome.</p><p>I’m a big fan of the saying “ask for forgiveness and not for permission” when we get to code deploy moments. Interacting daily with people who prefer to send an email, make a big plan, consult every stakeholder before applying a change, it just creates more bureaucracy. The planning of this entire change takes a week, when the actual change takes an afternoon! Organizations are faster when there&#39;s less dependencies. Many times, this excess of preparations and double/triple/quadruple checks with everyone that <em>possibly</em> <em>can be impacted</em> by something, is the result again of the same fear as the syndrome&#39;s.</p><p>Now for all the mid-level and senior engineers out there, who are overthinking around a task, I want to encourage: do it. Have a clear understanding of what you are doing and the environment around you, then get over the fear and do it. Delete the commented part of the code that will never be used again. You don’t need to save it! Git has it already. If you are causing a downtime, of course let’s plan for it first. But if you’re not, come on! Do it. Ship it. And then use the feedback cycle to improve again the process and your changes. Take the risk. Make things happen.</p><p>And finally about the mutt dog. Simply put: it’s wrong. It takes a while to realize but it’s just wrong. The language you code, how good you are at coding are not what takes you from staff to senior. And it’s even less relevant to the impact you are capable of doing. Being a senior is taking care of others, is taking the risk, is communicating clearly and brutally honestly to higher management, sharing clear expectations, and anticipating things that can go wrong.</p><p>And when you take the risk and things do go wrong, it’s still alright. The problem is not the error on your screen, the problem is not learning from it. So put your head up, say you messed things, fix it, and learn from it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=405c9aba0b52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Terraform code organization best practices]]></title>
            <link>https://guisester.medium.com/terraform-code-organization-best-practices-ef43d32eedb1?source=rss-5b92bb538ec3------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef43d32eedb1</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Guilherme Sesterheim]]></dc:creator>
            <pubDate>Wed, 10 Apr 2024 12:14:24 GMT</pubDate>
            <atom:updated>2024-04-10T12:14:24.612Z</atom:updated>
            <content:encoded><![CDATA[<p>Terraform is the most popular coding language for setting up infrastructure out there. It’s become so popular because it’s far better than the alternatives around. Better means easier to write, easier to learn, and most importantly easier to maintain. <a href="https://developer.hashicorp.com/terraform/language/syntax/configuration">HCL</a> (HashiCorp Configuration Language) plays a core role in the ease of writing and the maintainability when compared to its competitors.</p><p>I’ve been using Terraform for more than 6 years if not daily, weekly for sure, creating solutions for some of the biggest companies out there across different industries. And I’ll share two important topics I gathered during that work:</p><ol><li>Common pitfalls that will give you headaches in the long run if you don’t start right.</li><li>Best practices on how to organize your code inside repositories to make sure it’s as easy as possible to maintain it.</li></ol><h3><strong>Common pitfalls</strong></h3><p>All these pitfalls are totally understandable if you’re a beginner in Terraform, or if you have a huge pressure on your shoulders to deliver more infrastructure. But once you know them, it’s not an excuse anymore. The rework you’ll have in the long run if you fall for these pitfalls is enormous.</p><h4>1. One big state file (or many big state files)</h4><p>Extending the concept of using small files learnt with the Clean Code, a big state file will happen if you have too many responsibilities in your configuration (I’ll approach what is a Terraform configuration on the best practices below). So if you need to provision an S3 bucket, an EFS volume and a couple EC2 instances be sure to end up with at least 3 state files (3 per environment). Depending on how complex your EC2 module will get, you might want to consider breaking it into two. As an example: if you’re creating just the ENI, the EC2, and a couple EBS, that’s fine. But if you have a complex userdata to build, that’s another module and configuration, and therefore another state file. Also, if you have multiple EBS volumes to attach to a complex solution like SAP, that demands a new configuration/state file.</p><p>Now why is a big state file bad? Simply put, a big state file will always drag tons of dependencies at every Terraform plan. For example, you might want to do a very simple update in the lifecycle policy for your EFS files. But if your state file also includes your RDS, sooner or later you’ll see something changing and Terraform willing to destroy your database. So, be cautious.</p><h4>2. All the code everywhere all at once</h4><p>The second most common mistake is duplicating code (as it always is). Duplicate code will give you headaches when you have to do a change that should affect all your S3 buckets, for example. Let’s say you were just given a task to update the S3 bucket policies to allow an auditing account to read your files. If you don’t have a common single module that handles your buckets, you might very well consider the task done after changing 3 or 4 of them, and you’ll miss a couple more because it’s somewhere else in the code. That will generate rework in your team, and reduce your team’s trust from other teams.</p><h4>3. Not merging your branches</h4><p>This is straightforward. You have one branch per environment: dev, QA, prod. If you’re not testing your code in dev, then merging to QA, deploying, testing and only then merging to prod, you’re not trusting your code. It means you’re making changes straight to the environment branch without testing it in a lower environment before. So keep the code flowing from lower to higher branches. If you can’t merge it, red flag. The code should have variables that make it behave differently in different environments, so your merging keeps flowing.</p><h3><strong>How to organize your code</strong></h3><p>I’m suggesting three ways of organizing your code from worst to best. Head straight to the last one if you have a big team (~10 folks or more) working on provisioning your infra across multiple accounts. First and second suggestions are here just to cover some scenarios where companies have to adhere to policies like SOX, SCI, etc.</p><h4>1. One repo: configurations and modules in just one repository.</h4><p>In this case you have one repository. Pretty easy. Inside that, split your code into two folders: configurations and modules. This scenario will work pretty well if you have a small team (3 folks max) handling infrastructure for a small number of apps (max 5).</p><p>Modules: one folder per mode. You can consider modules as functions you’d write in an imperative language. You write modules in a generic way so you can reuse them as many times as you want.</p><p>Configurations: one folder per configuration. Every time you want to deploy one of your modules, you <em>call</em> them in a configuration. So the configuration is where you run your Terraform init/plan/apply from.</p><p>Example of how it’s gonna be in the end:</p><p>cloud-infra:</p><ul><li>folder — modules:</li><li>EFS</li><li>S3</li><li>EC2</li><li>Lambda</li><li>IAM</li><li>EKS</li><li>ECR</li><li>folder — configurations:</li><li>EFS</li><li>S3</li><li>EC2</li><li>Lambda</li><li>Etc</li></ul><h4>2. One repo for modules and X repos for the configurations</h4><p>In this case you’ll have one repository with the same contents of the folder modules above. What changes is that it gives you more flexibility and isolation for handling multiple applications. Imagine you have microservices, or multiple apps to deploy like Sonarqube, Jira, Prometheus, etc. In this case you will have one repository per application you need to deploy consuming the modules from a common repository. So when you’re changing Sonarqube’s database you’re sure you’re not touching Jira’s DB or Prometheus logs. And if you’re using microservices, you’re changing just the infra related to that specific microservice.</p><p>Example of how it’s gonna be in the end:</p><p>terraform-modules:</p><ul><li>EFS</li><li>S3</li><li>EC2</li><li>IAM</li><li>Lambda</li><li>Etc</li></ul><p>sonarqube:</p><ul><li>app folder 1</li><li>app folder 2</li><li>config folder</li><li>terraform</li></ul><p>microservice-1:</p><ul><li>app folder 1</li><li>app folder 2</li><li>config folder</li><li>terraform</li></ul><p>cloud-network:</p><ul><li>Terraform code in the root</li></ul><p>cloud-security:</p><ul><li>Terraform code in the root</li></ul><h4>3. One repo per module and one repo per configuration</h4><p>This is the most scalable and easiest to maintain in the long run. It also requires maturity and ownership from the team maintaining it.</p><p>Example of how it’s gonna be in the end:</p><p>TF-module-EFS:</p><ul><li>Terraform code in the root</li></ul><p>TF-module-S3:</p><ul><li>Terraform code in the root</li></ul><p>sonarqube:</p><ul><li>app folder 1</li><li>app folder 2</li><li>config folder</li><li>terraform</li></ul><p>microservice-1:</p><ul><li>app folder 1</li><li>app folder 2</li><li>config folder</li><li>terraform</li></ul><p>cloud-network:</p><ul><li>Terraform code in the root</li></ul><p>cloud-security:</p><ul><li>Terraform code in the root</li></ul><p>I hope it helps with avoiding issues while maintaining your Terraform infrastructure in the long run. If you’ve seen other patterns or see any flaws in the ones above, please share in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef43d32eedb1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>