Forem: DeveloperSteve

A Guide on Canary Deployments in Kubernetes

DeveloperSteve — Wed, 12 Apr 2023 00:46:18 +0000

In the world of software development, releasing new versions of applications can be fraught with risks. Ensuring that changes are introduced without disrupting the user experience is of paramount importance.

Canary deployments offer a reliable and efficient way to mitigate these risks by progressively rolling out new features to a small subset of users before making them available to everyone.

In this blog post, we'll delve into the intricacies of implementing canary deployments in Kubernetes and provide code samples to guide you through the process. Let's dive into the world of Kubernetes canary deployments and master the art of progressive releases!

Understanding Canary Deployments

Canary deployments get their name from the historical practice of using canaries in coal mines to detect dangerous gases. Similarly, canary deployments help detect issues in new releases by gradually rolling them out and monitoring their performance. By limiting the exposure of new features to a small percentage of users, developers can identify and address potential problems before they affect the entire user base.

Prerequisites

For the purpose of this guide, we assume that you have a basic understanding of Kubernetes concepts and have access to a running Kubernetes cluster. We will be using a sample application with two versions (v1 and v2) for demonstration purposes.

Creating the Base Deployment and Service

First, let's create a base deployment for our application with the v1 version. Create a deployment.yaml file with the following content:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-v1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
      version: v1
  template:
    metadata:
      labels:
        app: my-app
        version: v1
    spec:
      containers:
      - name: my-app
        image: my-app:v1
        ports:
        - containerPort: 8080

Apply the deployment using kubectl:

kubectl apply -f deployment.yaml

Next, create a service.yaml file for our application:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

Apply the service using kubectl:

kubectl apply -f service.yaml

Implementing Canary Deployment

To implement a canary deployment, we'll create a separate deployment for the v2 version of our application with a single replica. Create a canary-deployment.yaml file with the following content:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-v2
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
      version: v2
  template:
    metadata:
      labels:
        app: my-app
        version: v2
    spec:
      containers:
      - name: my-app
        image: my-app:v2
        ports:
        - containerPort: 8080

Apply the canary deployment using kubectl:

kubectl apply -f canary-deployment.yaml

Configuring Traffic Splitting

In order to direct a portion of the traffic to the v2 version, we'll use Istio, a popular service mesh for Kubernetes. Ensure that Istio is installed and enabled in your cluster. To configure traffic splitting, create a virtual-service.yaml file with the following content:

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: my-app-virtual-service
spec:
  hosts:
    - my-app-service
  http:
    - route:
        - destination:
            host: my-app-service
            subset: v1
          weight: 90
        - destination:
            host: my-app-service
            subset: v2
          weight: 10

In this configuration, we're directing 90% of the traffic to the v1 version and 10% to the v2 version (our canary release). Apply the virtual service using kubectl:

kubectl apply -f virtual-service.yaml

Monitoring and Observability

Effectively monitoring and observing the performance of canary deployments is a crucial aspect of ensuring their success. By collecting metrics, logs, and traces from both the v1 and v2 versions, you can identify discrepancies or issues that might be introduced by the new release. Kubernetes offers built-in monitoring tools like Prometheus and Grafana to facilitate this process, but third-party observability services can further enhance your monitoring capabilities.

One such third-party service is Lumigo, which provides comprehensive observability for serverless applications, microservices, and Kubernetes clusters. Lumigo enables you to monitor the performance and stability of your canary deployments with real-time insights, helping you detect potential issues early in the process.

To integrate Lumigo with your Kubernetes cluster, you can use the Lumigo Kubernetes Operator. This open-source project is available on GitHub at https://github.com/lumigo-io/lumigo-kubernetes-operator. The Lumigo Kubernetes Operator automates the deployment and management of the Lumigo tracer in your Kubernetes environment, ensuring seamless integration with your existing monitoring setup.

To get started with the Lumigo Kubernetes Operator, follow the installation and configuration instructions provided in the project's GitHub repository. Once the operator is deployed and configured, it will automatically inject the Lumigo tracer into your cluster's pods, enabling end-to-end monitoring of your applications.

With Lumigo, you can gain valuable insights into the performance and health of your canary deployments. The platform provides real-time metrics and visualisations, making it easy to compare the performance of the v1 and v2 versions of your application. If you detect any problems or anomalies, you can quickly roll back the canary release by adjusting the traffic split in the virtual service or by removing the v2 deployment.

Scaling Canary Deployments

Once you've confirmed that the canary release is stable and functioning as expected, you can gradually increase the traffic to the v2 version by adjusting the weights in the virtual service. This allows you to safely roll out the new version to more users, while still keeping an eye on performance metrics.

When you're ready to fully transition to the new version, update the base deployment to use the v2 image and remove the canary deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app-v1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
      version: v1
  template:
    metadata:
      labels:
        app: my-app
        version: v1
    spec:
      containers:
      - name: my-app
        image: my-app:v2
        ports:
        - containerPort: 8080

Apply the updated deployment using kubectl:

kubectl apply -f deployment.yaml

Release your Canary deployment into the wild

Canary deployments in Kubernetes provide a reliable and efficient way to progressively roll out new features, allowing developers to identify and resolve issues before they impact the entire user base.

By leveraging Istio and monitoring tools, you can confidently introduce changes to your applications with minimal disruption. Master the art of canary deployments in Kubernetes and take your application releases to new heights!

Happy kubernetesing ☸️

Advanced Regex Techniques to Spice Up Your Text Processing

DeveloperSteve — Tue, 04 Apr 2023 23:52:27 +0000

Are you ready to embark on an exhilarating Regex adventure? Regular expressions, affectionately known as Regex, are a text processing wizard's best friend. Although mastering the basics is essential, it's the advanced techniques that will transform you from a Regex apprentice to a true pattern-matching sorcerer. In this blog post, we'll delve into some of the more fascinating Regex features, including lookaheads, lookbehinds, backreferences, and recursive patterns. Buckle up, and let's dive into the realm of advanced Regex text processing.

Lookaheads: A Glimpse into the Future

Lookaheads are like fortune tellers of the Regex world. These clever assertions allow you to peek into the future of your input string without actually matching the lookahead pattern. Lookaheads come in two enticing flavors:

Positive lookahead (?=pattern): Proclaims that the pattern exists after the current position.
Negative lookahead (?!pattern): Insists that the pattern is nowhere to be found after the current position.

Example:

Picture this: you want to find all the words followed by a comma but don't want the comma to crash the party. Fret not! Use a positive lookahead like this:

\b\w+(?=,)

Lookbehinds: Don't Forget to Look Back!

Lookbehinds are the time-travelers of Regex, allowing you to journey back in time and check for a pattern before the current position. These crafty assertions also come in two intriguing forms:

Positive lookbehind (?<=pattern): Asserts that the pattern has left its mark before the current position.
Negative lookbehind (?<!pattern): Declares that the pattern never dared to step foot before the current position.

Example:

Say you're hunting for words that have a dollar sign as their trusty sidekick, but you don't want the dollar sign stealing the spotlight. Fear not! A positive lookbehind is here to save the day:

(?<=\$)\w+

Backreferences: Déjà Vu, Anyone?

Backreferences are like the boomerangs of Regex - they allow you to refer to a previously captured group within the same expression, creating a sense of déjà vu. You can summon a captured group using the magical incantation \1, \2, \3, etc., with the number corresponding to the group's position in the pattern.

Example:

If you're on a quest to uncover repeated words in a text, unleash the power of a backreference like this:

\b(\w+)\s+\1\b

Recursive Patterns: Taming the Nested Beasts

Nested structures, such as parentheses or HTML tags, can be the dragons of the Regex realm. Fear not, brave Regex warrior! Some regex engines (like Perl, PCRE, and Python's regex module) support recursive patterns, empowering you to slay even the most formidable nested beasts.

Example:

To conquer the challenge of balanced parentheses, arm yourself with a recursive pattern like this (using the PCRE engine):

\((?:[^()]|(?R))*\)

By harnessing the enchanting powers of advanced Regex techniques like lookaheads, lookbehinds, backreferences, and recursive patterns, you'll become a true text-processing champion. These mystical abilities grant you precision and control when facing complex patterns, allowing you to vanquish even the most fiendish text-processing foes. Embrace your inner Regex adventurer, and don't be afraid to experiment and combine these powerful techniques to unleash your full pattern-matching potential.

Helm, the Enchanted Scepter: A novice's Guide to level 5 Kubernetes spells

DeveloperSteve — Tue, 04 Apr 2023 03:30:36 +0000

In the mystical land of container orchestration, Kubernetes reigns supreme. But as powerful as Kubernetes may be, it can sometimes feel like navigating a labyrinth of YAML files and manifests. Fear not, brave adventurer, for there exists a magical tool to tame the complexity of Kubernetes: Helm, the package manager of Kubernetes.

Just as a trusty map guides weary traveler's through treacherous dungeons, Helm charts guide developers through the intricate process of deploying and managing applications on Kubernetes. In this quest, we shall embark on a journey to master Helm and harness its power to bring order to the chaos.

Step 1: Acquiring the Helm

First, we must acquire Helm and install it on our local machine. Follow the instructions for your platform from the Official Helm Documentation

Step 2: Initializing the Helm

Once Helm is installed, we can summon its powers by invoking the command:

helm version

This incantation will reveal the Helm version, proving that the summoning was successful.

Step 3: Conjuring the Repository of Charts

With Helm at our disposal, we must now seek knowledge in the form of Helm charts. These arcane artifacts provide templates for deploying and managing applications on Kubernetes. We shall add the official repository of charts known as "Bitnami" to our Helm:

helm repo add bitnami https://charts.bitnami.com/bitnami

To ensure the repository has been successfully added, recite the following command:

helm repo list

Step 4: Unveiling the Charts

The Bitnami repository contains a vast trove of Helm charts. To uncover them, we shall issue the following command:

helm search repo bitnami

This will reveal the charts available in the Bitnami repository, ready for your perusal.

Step 5: Summoning the Application

To demonstrate the power of Helm, we shall now summon an application. Let us choose the mighty "nginx" chart and install it on our Kubernetes cluster:

helm install my-nginx bitnami/nginx

This enchantment will create a new release called "my-nginx" using the "bitnami/nginx" chart. Once the spell is complete, Helm will provide instructions on how to access your newly summoned application.

Step 6: Manipulating the Application

As your mastery over Helm grows, you may wish to manipulate the summoned application. To do so, first inspect the chart's values:

helm show values bitnami/nginx

This will reveal the editable parameters within the chart. To alter these values, create a new file called "values.yaml" and apply your desired changes. Then, update the release using the following incantation:

helm upgrade my-nginx bitnami/nginx -f values.yaml

Step 7: Banishing the Application

Should you wish to banish your application from the cluster, simply utter the following command:

helm uninstall my-nginx

And just like that, your application will vanish into the void.

Congratulations, adventurer!

You have now traversed the basics of Helm and tamed its formidable powers. With Helm by your side, you shall fearlessly journey through the realm of Kubernetes, conquering complexity and vanquishing disorder. May your path be ever guided by the wisdom of Helm charts!

Serverless Days ANZ 2023 Recap

DeveloperSteve — Wed, 15 Mar 2023 04:51:34 +0000

Serverless Days ANZ 2023 was a fantastic event that showcased the vibrant serverless community. From the opening keynote to the final panel discussion, there was a palpable energy in the air as attendees shared their experiences, insights, and best practices on all things serverless. The event was a true testament to the power of community and collaboration, bringing together developers and architects from across the ANZ region and beyond.

Speakers like AWS Serverless hero Jeremy Daly and Kris Howard from AWS spoke about the importance of a well-designed developer experience and thinking in integration patterns. The event also featured panel discussions and a range of topics from security to accessibility.

The IoT trace wire game that I shared with the audience was an exciting project that Lumigo used in our booth for re:Invent last year. The game involved players navigating through a wire maze as quickly as possible, with their times recorded and sent via WiFi to a Lambda function and stored in DynamoDB. This allowed us to trace the entire process using Lumigo, demonstrating the power and usefulness of serverless computing.

The game was a real challenge to build, requiring a lot of logistical planning and work pivots, as well as extensive tinkering with IoT hardware and 3D printing. But the end result was a lot of fun for everyone involved, including myself. If you're interested in learning more about my experience building this game and how we used Lumigo to trace it, be sure to check out my blog post on Observing IoT and Lambda.

Join us in celebrating the serverless community spirit and the hardworking team that made this event possible.

Read more about the event and my experience on the Lumigo blog via this link 👉 https://lumigo.io/blog/serverless-days-anz-2023-recap/

Pobody is Nerfect and ChatGPT is no exception

DeveloperSteve — Wed, 25 Jan 2023 02:30:21 +0000

In the span of only a few weeks we saw the emergence of many new integrations options for the newly spawned AI service. From Discord to IDE's, we have seen a multitude of options enabling automated experiences that go to a whole new level of engagement with its users.

ChatGPT, or Generative Pre-trained Transformer 3, is already revolutionising industries even in its emergence infancy. However, as with any technology, there are bound to be mistakes. So, what do we do when ChatGPT gets things wrong?

First and foremost, it is important to understand that ChatGPT is a machine learning model and, as such, it is not perfect. It is not a human and does not have the same level of understanding or ability to process information as a human does. Therefore, it is important to approach any output from ChatGPT with a critical eye and not assume that it is always correct.

One way to address errors in ChatGPT's output is through fine-tuning. Fine-tuning involves training the model on a specific dataset or task, which can help improve its performance. For example, if ChatGPT is being used in a customer service chatbot and is consistently misunderstanding a certain type of question, fine-tuning the model on a dataset of similar questions can help improve its understanding.

The most important way to address errors in ChatGPT's output is through human oversight. This can be as simple as having a human review and approve any output from the model before it is sent to a customer or user. This can help catch any errors or inconsistencies that the model may have generated. Additionally, feedback from human users can be used to improve the model over time and or to refine the service that it is utlized within.

Of cour it is important to note that ChatGPT's errors can be related to the data that it has been trained on. Like any AI model, ChatGPT's performance is only as good as the data it has been trained on. This means that if the data used to train the model is biased or contains errors, the model's output will also be biased or contain errors. To avoid this, it is important to use a diverse and high-quality dataset when training the model.

AI applications like ChatGPT, are powerful tools that have immense potential, but it is not without its mistakes especially in its pursuit to appear human. Addressing errors in ChatGPT's output requires a combination of fine-tuning and building in human oversight, especially for critical tasks.

Comparing Amazon ECS launch types: EC2 vs. Fargate

DeveloperSteve — Wed, 18 Jan 2023 02:58:33 +0000

Amazon Elastic Container Service (ECS) is a fully managed container orchestration service that enables users to easily run, manage and scale containers on AWS. With ECS, you can deploy containers either on a cluster of Amazon EC2 instances or on AWS Fargate, a serverless computing engine for containers. In this article, we’ll take a closer look at what ECS is and how it works, including the different components and launch types available.

In this article, we’ll take a closer look at what ECS is and how it works, including the different components and launch types available. We'll also briefly compare the features of EC2 and Fargate, and explore the use cases for each launch type. By the end of this article, you'll have a better understanding of how to use ECS and be able to make an informed decision on which launch type is best for your needs.

But first, let's define what ECS is. ECS is a highly scalable and powerful tool for orchestrating containers that are run on Docker. It allows you to deploy containers from your local environment via Docker and provision access to those containers from anywhere, resulting in zero downtime and no complicated configurations. With ECS, you can scale numerous containers with just a single click.

ECS provides the underlying infrastructure to create task definitions for your tasks and services; however, you still have to select a launch type that will handle running, stopping, and deploying your tasks and services.

Want to find out more?

Follow this link to read the full article and learn how to use ECS to manage and scale your containers on AWS, and take the first step towards streamlining your container orchestration process.

Regex, dont be scared

DeveloperSteve — Thu, 08 Dec 2022 23:42:42 +0000

As a developer, you may have heard of regular expressions, also known as regex, and may have even avoided using them because of their reputation for being difficult and intimidating. However, regex is actually a powerful and useful tool that can greatly simplify your code and save you time and effort. Here are a few reasons why you should not be scared of regex and why you should consider using it in your development projects.

First and foremost, regex is a concise and efficient way to match patterns in a multiple of programming languages. Instead of using lengthy and complex code to search for specific patterns, regex allows you to define a pattern in a simple and intuitive way. For example, the following regex pattern will match any string that starts with "hello" and ends with "world":

/^hello.*world$/

Not only is this pattern much easier to read and understand than a longer and more complex code, it is also more efficient and faster to execute. By using regex, you can easily search for and match patterns in strings, making your code more efficient and effective.

Another reason to not be scared of regex is that it is a versatile and flexible tool. Regex can be used for a wide range of tasks, from simple string matching to complex data manipulation and validation. For instance, you can use regex to validate email addresses, phone numbers, URLs, or any other type of data. The following regex pattern will match any valid email address:

/^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/

By using regex, you can easily and accurately validate data, ensuring that your code only processes valid and correct inputs. This can save you time and effort, and can prevent errors and bugs in your code.

Finally, regex is a widely used and supported tool that is available in many programming languages and frameworks. Most modern programming languages and frameworks have built-in support for regex, allowing you to easily integrate regex into your code. For instance, the following code snippet shows how to use regex in JavaScript:

let regex = /^hello.*world$/;
let string = "hello world";
let result = regex.test(string);

By using regex, you can benefit from the extensive support and resources available for this tool, and can easily integrate it into your development projects.

What i love about regex the most is it being a powerful and useful tool that can greatly simplify your code and save you time and effort. It is a concise and efficient way to match patterns in strings, a versatile and flexible tool that can be used for a wide range of tasks, and a widely used and supported tool that is available in many programming languages and frameworks.

Don't be scared of regex – embrace it and start using it in your development projects.

The Hidden Costs of Serverless Observability

DeveloperSteve — Thu, 08 Dec 2022 23:05:57 +0000

Serverless architectures are becoming increasingly popular, which has led to an increased need for solutions to the challenges of microservice observability. Observability solutions enable fast and easy debugging of applications, as well as driving optimization and cost efficiency. However, the complexity of serverless systems presents challenges to observability, and the wrong tool set can lead to unexpected costs.

In a serverless environment, not only are developers abstracted from the underlying infrastructure that runs their code, but the distributed, event-driven nature of serverless applications makes traditional approaches to monitoring and debugging ineffective. Serverless functions are often chained through asynchronous event sources such as AWS SNS, SQS, Kinesis, or DynamoDB, making tracing extremely difficult.

The distributed nature of serverless architectures makes monitoring harder, as there isn't one central, monolithic application server anymore. Instead, developers are faced with a distributed architecture and an abundance of competing tools to conduct serverless monitoring.

Serverless observability tools are purpose built to support serverless architectures. They allow developers to reap all the benefits of serverless technology without sacrificing insights into the system, allowing them to retain opportunities to catch errors and optimize for cost and responsiveness.

Building an observability solution tailored to a serverless system requires data, and a lot of it. Logs, metrics, and traces are required to ensure the system can answer as many questions as possible about how it's working, whether you're repairing or optimizing. Each source contributes a different perspective on how your application is performing and, when analyzed together, give a complete picture of its health.

There are many different serverless observability tools available, each with its own unique features and capabilities. Choosing the right one for your needs can be a daunting task. Some popular options include IOpipe, Dashbird, and Epsagon.

Follow this link to read more

Getting started with Bun.js

DeveloperSteve — Thu, 08 Dec 2022 22:52:37 +0000

Bun.js is a powerful JavaScript framework that allows you to easily create dynamic and interactive user interfaces. In this blog post, we will go over some of the basics of using bun.js and how you can get started with it.

First, let's go over what bun.js is and why you might want to use it. Bun.js is a front-end framework that makes it easy to build complex user interfaces using a declarative approach. This means that you can describe what your user interface should look like, and bun.js will take care of the details of rendering it on the page. This is in contrast to imperative approaches, where you have to write code to manually manipulate the elements on the page.

One of the key features of bun.js is its reactive nature. This means that when data changes in your application, the user interface will automatically update to reflect those changes. This can make it much easier to build dynamic and responsive applications, as you don't have to worry about manually updating the user interface whenever the data changes.

Now that you have an idea of what bun.js is and why you might want to use it, let's go over how you can get started with it.

The first step to using bun.js is to include the bun.js library in your HTML page. Most commonly this can be done by adding a <script> tag to your page that points to the bun.js library. You can either download the library and include it locally, or use a CDN (Content Delivery Network) to include it in your page.

Once you have included the bun.js library in your page, you can start using it to build your user interface. The first thing you will need to do is create a bun.app object, which will be the root of your user interface. This can be done by calling the bun.app() function and passing it a DOM element where you want the user interface to be rendered.

Once you have created a bun.app object, you can start defining the components of your user interface. This is done using the bun.component() function, which allows you to create custom components that you can use to build your user interface. A component is a self-contained piece of the user interface that can be reused in different parts of your application.

To create a component, you simply call the bun.component() function and pass it a name and a function that returns the component's template. The template is a string of HTML that describes the structure of the component. You can use the special bun-bind attribute to bind data to the template, which will cause the user interface to update automatically whenever the data changes.

Once you have created your components, you can use them to build your user interface by using the bun-component attribute on DOM elements in your template. This will tell (bun.js)[https://bun.sh/] to render the specified component in that spot in the user interface.

In addition to components, bun.js also provides a number of built-in elements and features that you can use to build your user interface. These include things like bun-if and bun-for attributes for conditional rendering and looping, bun-click for handling user interactions, and much more.

By following these steps, you can get started with bun.js and begin building dynamic and interactive user interfaces. With its powerful reactive capabilities and easy-to-use syntax, bun.js is a great choice for building modern web applications.

Tracing and Observing AWS ECS

DeveloperSteve — Thu, 08 Sep 2022 06:02:02 +0000

It’s no secret that application containerization has revolutionized the digital world as we know it by providing a transient gateway into elastic infrastructure that can scale and grow as needed. Where traditional virtualization was all about creating a single homogenous entity, containers are self-contained units of software, able to run in just about any environment, making them extremely portable.

Like with all excellent adventures, there are a few things we need to prepare before we begin our journey. Have an AWS account set up and at least one ECS cluster deployed—extra points for also having a few Lambdas or other traceable services.

The other thing you will need is a Lumigo account that is connected to your AWS. It’s easy to do, free, and only takes a few minutes.

To get started, head to the Lumigo signup page and create your account by clicking the “Continue with Google” button, or by entering an email and password. The next step is then to connect your AWS account by clicking the “Connect to AWS” button.

Once the AWS connection process is complete, Lumigo will automatically start scanning for services and applications to trace from the connected account. This process will identify resources of interest and will start tracing them in your Lumigo instance.

Give it a few moments to complete the initial scans, then explore your newly created Lumigo account to see which applications have been observed and discovered. Clicking into the ECS tab from your Lumigo instance will display any clusters that Lumigo has detected from your connected AWS account.

It’s really important to note here that those cluster metrics are only visible if you have CloudWatch container insights enabled on your cluster.

Clicking into a monitored ECS application will display an overview for a cluster that includes metrics such as CPU and Memory utilization alongside running task metrics. These metrics combined give a useful insight into where resources are being consumed and the timing associated with their usage.

This is where things get REALLY interesting.

By adding the Lumigo tracers into our application you can gain even more insight into the inner workings of your ECS container applications.

To get started all you need to do is add a library, a few lines of code, and some environmental variables. This will slightly vary depending on what your language and codebase look like, but first, let’s check out some libraries.

Lumigo has some open-source libraries for getting trace information from your application. It currently supports [Python}(https://github.com/lumigo-io/opentelemetry-js-distro) and NodeJS languages.

Install the library with your nominated package manager and reference the library from within your application. Again, this may vary slightly depending on how your application is structured.

Finally, we need to set 2 environmental variables on the container as part of its deployment to ECS. These can be set within the code as part of the library, but it is highly recommended to set these as environment variables.

Now we will be able to see a lot more information from that ECS cluster application, right down to the application level and beyond. Clicking through from the services button on the cluster overview page will whisk you away to the Explore page with a resource filter set.

This will then let you see additional information from a trace and view the associated invocation in greater detail.

From the invocation view page you can see any associated connected services, which is really handy to being able to see the full end to end trace view from your ECS deployments.

To read more check out Observing ECS Containers

Observing AWS ECS deployments

DeveloperSteve — Tue, 06 Sep 2022 03:39:32 +0000

To look at it another way, and to build on a popular quote with ancient origins, “With great scale comes the need for great observability”. Tracing and monitoring can help surface these issues while observing the resources being utilized by your containers.

Here’s how to get started on observing and monitoring your ECS clusters with Lumigo.

The other thing you will need is a Lumigo account that is connected to your AWS. It’s easy to do, free, and only takes a few minutes.

This is where things get REALLY interesting.

By adding the Lumigo tracers into our application you can gain even more insight into the inner workings of your ECS container applications.

Lumigo has some open-source libraries for getting trace information from your application. It currently supports Python and NodeJS languages.

If you are using another language for your application, you can still connect your trace information, but you may need a few additional steps and should use one of the OpenTelemetry collector libraries.

Install the library with your nominated package manager and reference the library from within your application. Again, this may vary slightly depending on how your application is structured.

OTEL_SERVICE_NAME

This sets the application name on the service application traces and should reflect something specific to the application being traced within this container.

LUMIGO_TRACER_TOKEN

This helps identify your traces to your Lumigo instance. It can be found by visiting Settings and then Tracing from your Lumigo dashboard.

Check out tracing and observing AWS ECS to read more

With great scale comes great observability

DeveloperSteve — Tue, 23 Aug 2022 07:47:46 +0000

Building on Microservices is a great way to deploy applications that can scale with rapid adoption. Scaling modern microservice applications generates a large amount of logs and metrics data on multiple levels, having the right tools to manage them all is integral to microservices success. Modern architecture needs a new approach and for microservices, distributed tracing brings monitoring into the modern world of observability.

Join us for the live session, 31st of August 9am ET

In this live geek out session, we will get hands on deploying a multi-microservices application to AWS ECS and use distributed tracing to find, track and troubleshoot issues

Click here to find out more