 Hello, everyone. I want to welcome you all to this presentation where I'll be discussing how you can build CI CD pipelines that support ARM architectures and processors. My name is Angel Rivera. I'm a developer advocate for CircleCI. And again, I'm super excited to be talking to you about ARM architectures and processors. As many of you know, ARM architectures have been around for quite some time, right? Processors have been embedded in hardware in different shapes and forms for some years now. And these are the more commonly types of devices or hardware that have ARM processors powering them. Things such as mobile phones or smartphones, tablets, raspberry pies, and IoT and smart devices, such as TVs, appliances, wearables, and even certain medical devices. So again, ARM architectures have been around for quite some time. There are a lot of the devices that we use on a daily basis. And the reason for their high adoption in the mobile space and other smart device type spaces is because of their low power consumption. So we're usually carrying a phone around, and that requires a battery. The processor's ability to process data using very minimal energy is one of the appealing aspects of implementing or adopting ARM architecture within the mobile devices. Certain operating systems have been supporting ARM architectures and processors for quite some time. And more recently, Apple has basically adopted the ARM processors into their current and new releases of their MacBook laptop devices, as well as any other kind of desktop or server devices that they're going to push out in the future. So having that popularity of adoption with ARM by Apple, it's just gaining more popularity in the industry. Now, servers have adopted ARM architectures and processors for a while now. This is not anything new, but it is gaining popularity in the infrastructure spaces. So the cloud providers are now providing options for developers to basically leverage ARM hardware within their services. AWS Graviton 2 is a good example of that. They've actually implemented a new instance type that basically is powered by ARM processors that enables, again, the floodgates to open for the usage of ARM within these provider services. The problem is that ARM and x86 processors are not compatible, which leads to applications that were built for x86. Processors are not going to function well with an ARM ecosystem, right? So that means the instructions sets are just different. So again, that basically means that the applications have to be compiled for the processor that they're targeting. Again, code doesn't really care about where it's executed on, but it does need to be compiled for whatever processor or environment it's going to be working on. In this case, we're going to be compiling applications for ARM architectures and processors, and that must actually be done on the hardware itself, right, so that you can get the proper instructions for your application. CircleCI has recognized this, and we're actually, we've created a new resource class is what we're calling it, which is a compute node where you can execute your CI CD pipelines on ARM hardware. Now, while doing that, essentially, you know, we'll give the developer the ability again to, you know, compile their code, and then ensure, test their code, ensure that it's actually functioning specifically on the ARM architecture, right, for the ARM processors, as well as the ability to do the same for an x86 architecture. So now we're just giving the developer a bunch more power to be able to, you know, build applications for whatever target hardware that they need to, you know, build for. So now I'm going to jump into a demonstration of how you can build CI CD pipelines and support those builds using ARM platforms within your CI CD pipelines. So before we jump in, I wanted to show you some code. I have a project here that essentially is a simple Node.js application. The application should not be your focus at this point. What I'm going to focus in on is how you can implement ARM capabilities into your CI CD pipelines using the CircleCI config.yaml file, which is the way you define CI CD pipelines in the CircleCI platform. Now, this is a collapsed version of the pipeline. And the reason why it collapsed it was so that I can focus in on the bits that actually matter. So this configuration pipeline configuration has four jobs in it. One is obviously to run some tests. The other one is to build a Docker image. And then the other two are leveraging infrastructure as code, a tool called Terraform created by or maintained by created and maintained by a company called HashiCorp. So basically what's going to happen here is we're going to run some build our code, run some tests, we're going to build a Docker image based off of that code. And it's going to be an ARM compatible Docker image. And then finally we're going to deploy, we're going to create using infrastructure as code, create a Amazon elastic container service cluster. And that's going to be powered by ARM compute nodes that are basically powering the cluster. So finally we're going to destroy all of that using a manual button push and circle CI. So let's jump into it real quick. I just want to show you how you can easily implement this. And in the run test job, which I'm showing here, we're going to create a machine executor, which is the resource class or the type of environment that we're going to execute our code on. And we're going to be using an Ubuntu image, Linux Ubuntu image. And this is basically how you would just, you know, specify that you want to use an ARM compatible or ARM capable hardware or executor within your CI CD builds. And it's just that simple, right, just saying ARM dot medium or ARM dot large. And essentially the system knows to spin up an ARM environment for you so that you can run your code. I'm not going to go too deep into this code, but essentially, right, you're just looking at the important bits of how to build a CI CD pipeline that supports ARM. And this is essentially how you would do it. You just tell the resource class key that you want an ARM resource class, and then it will create that for you. So let's go ahead and just change the application. I just want to demonstrate how easy it is to implement this in your pipeline. So I'm going to go ahead and create a version to just change the value. Again, the application is not really the focus here. But we're going to go ahead and commit those changes. So let's do a get status, make sure that we do have some changes to commit. And we do want to do a get commit. And then it's the application fjs that we want to commit, give it a message with the lower M. And then we're going to say, I don't know, updated the version number, which is what we did, right? And then we're going to go ahead and essentially just push our changes upstream to our version control system. Now, this is where CircleCI will jump in and pick up the fact that, you know, we push some changes to our version control system, and it detected those changes. CircleCI triggered that pipeline build that we had in our config.yaml file. So all of these things are now running, right, inside of our pipeline, and they're running on ARM based executors or hardware. So while that's happening, let's go ahead and look at the dashboard real quick so that we can see exactly what's going on. I'm running three jobs in parallel, right? So this is what that kind of looks like. And as you can see, we're running our tests, we're building our Docker image, and we're also creating the AWS infrastructure that we're going to deploy to. So the initial segments of our build have completed. And if we want to dig into one of these, let's go ahead and look at the build Docker image job. Essentially, what we've done here is created an ARM compatible Docker image, right, so that we can deploy this to ARM hardware. And what we have here is essentially, you know, the designator for the executor, which is where the environment where we, you know, built our code and built our Docker image. And again, right, it's an ARM Linux medium, as opposed to an x86 platform. Now let's take a look at what exactly happened within our pipeline again. So we've run our tests, we've built the Docker image. And now let's take a look at our deploy to AWS ECS. So with the Terraform application running, again, we're using an ARM executor here. And it's built the infrastructure using Terraform on an AWS cloud. So let's go ahead and just see if our application is actually running. Now remember, we updated the application to version two. So hopefully, oh, it's still running version one. So let's go ahead and see what's going on there. I'm going to go ahead and click in here in our cluster. And then I'm going to look at the task because that's what we're looking at. So now we have tasks that are updated, they look like they're running. It may have been that they were still in the process of updating. So the way it works is because of its scaling, and you can see here, right, basically, it's a deployment. So it's just replacing the old containers with the new containers which contain this release of the application. So let's go ahead and try it again and see if we can get to our version two of the application, which is version two. Great. So we've deployed this application with ARM capable docker images that were built on ARM, CircleCI's ARM resource class executors. And then also we've used Terraform to build out a Amazon ECS cluster based off of EC2 instances that are powered by the Amazon Graviton 2 ARM instances, right? So now everything's kind of end-to-end ARM. You know that your application compiled in ARM infrastructures, you know that your application has been deployed using a docker container to an ECS cluster that is also based off of ARM capable or ARM powered compute nodes. So you have a full end-to-end experience there with ARM, and you know that your application is basically fully compatible with the ARM architecture. Now coming back to the pipeline, I wanted to show you that these are three things that ran in parallel, they ran pretty quickly as you can see. Sometimes it takes a little bit of time for the underlying cloud infrastructure or the environment you're deploying to to actually change the application and update the new version through a rolling release or a rolling deployment, I should say. So finally I just wanted to show you this last bit, which is basically where you get to, you can instantiate or define a step in your pipeline that adds some manual capabilities. So this manual step requires someone to actually click a button, in this case it's the approve this job, and once you click this button, it's like a block and then it continues to the next job in the pipeline, which in this case is going to be destroying all of that awesome AWS ECS clusters and all that stuff that we built. So let's go ahead and click on that button so that we can destroy our infrastructure since we don't need it anymore, right? This is for demonstration purposes, but what it'll essentially do again is to go into Amazon and terminate all of the resources and all of the objects that it created that were needed for our ECS cluster, things like VPC, security groups, IAM roles, the Graviton 2 cluster nodes that we created to support to host our application in our ECS cluster. So I click the approval button, the destroy process is happening. Let's go ahead and take a look at what's happening actually, and it's essentially running Terraform right and destroying all this cloud infrastructure that was created in our previous job within this pipeline. Now, when this is completed, all of that stuff will be terminated, that we created in Amazon will be gone and not functioning anymore. And again, this will have a should lead to a green build, but I just wanted to show you the power of the CircleCI pipelines and how it can be used to implement ARM architectures so that now developers can build their applications with confidence using ARM processors as well as deploying to ARM powered infrastructures such as Amazon ECS on Amazon's Graviton 2 compute nodes. So I want to say thank you to all of you for attending and if there's any questions or comments or just want to have a chat, please hit me up on Twitter. My handle is at punkdata. And once again, thank you all.