A Developer's Playful Tale of JSON Validation & AWS Lambda | App Config

Must Read:

• Setup An Application

If you have gone through the previous lessons, I assume you already have an application set up in the AWS AppConfig.

Gather around, fellow developers and DevOps enthusiasts! Let me share a story that’s sure to put a smile on your faces. Remember the time when you were working on AWS AppConfig and suddenly found yourself in the treacherous waters of Lambda validation? Well, it happened to me too. It was one of those days when the weight of common config app issues was bearing down on me, and I needed a solution, pronto!

Pros:

• Error reduction: JSON validation against schema helps reduce errors by ensuring that JSON data adheres to predefined rules and formats. This can save you time and effort in debugging and troubleshooting.

• Easy maintenance and updates: AWS AppConfig allows you to easily manage and update your application’s configuration without having to redeploy the entire app. This can greatly improve your agility and responsiveness when addressing issues or making changes.

• Feature flags for controlled rollouts: Using feature flags (or toggles) enables you to gradually roll out new features, giving you better control over their deployment and reducing the risks associated with large-scale changes.

• Scalable and cost-effective: AWS Lambda provides a serverless architecture that scales automatically based on demand, ensuring optimal resource usage and cost-efficiency.

• Improved collaboration: AWS AppConfig, Lambda, and feature flags facilitate better collaboration between developers and DevOps teams, promoting a shared understanding of the application and its configuration.

Cons:

• Complexity: The combination of AWS AppConfig, Lambda, and JSON validation may introduce some complexity, especially for those who are new to these tools and technologies. It may take time to learn and become proficient in using them.

• Dependency on AWS: Using AWS AppConfig and Lambda ties your application configuration and serverless architecture to AWS. This could make it more challenging to migrate to other cloud providers in the future if needed.

• Potential for misconfigurations: While JSON validation can help prevent errors, it’s still possible to introduce misconfigurations if the schema is not well-defined or if validation rules are too permissive.

• Cost concerns with Lambda: While Lambda is cost-effective for many use cases, in some scenarios (e.g., long-running tasks or applications with a high volume of requests), the cost of Lambda invocations can add up and become expensive.

• Cold starts in Lambda: AWS Lambda functions may experience a slight delay during their initial execution, known as a “cold start.” This can impact performance, especially for applications with low-latency requirements.

“But what is the use of JSON validation?” you might ask. JSON validation, my friends, is like the Gandalf of coding, keeping your JSON configuration safe from the Balrog of errors. As they say, “Not all those who wander are lost,” and that’s where JSON validation against schema comes into play. Now, let me walk you through a thrilling tale of how I tackled the Lambda validator for AWS AppConfig.

Step 01: Open the configuration profile

One sunny day, I was working on an AWS AppConfig example, sipping my coffee and humming to my favorite tunes. I had a task at hand: to open the configuration profile. My AWS feature flags were ready to be unleashed, so I opened the AWS Management Console and navigated to AppConfig. As I clicked on “Configuration profiles,” I felt a sense of excitement, like Frodo Baggins embarking on his quest to destroy the One Ring.

Step 02: Update the configuration profile

Now that my configuration profile was open, it was time for an update. I dove headfirst into the world of AppConfig feature flags, making necessary modifications to incorporate the latest feature toggle Python code. Just like a skilled gardener tending to their beloved plants, I nurtured my configuration profile, ensuring it blossomed into a well-crafted and efficient tool.

Click on the Action -> Update configuration profile and then Add a New Validator.

Step 03: Use the following JSON Schema Validator

I then turned my attention to JSON Schema Validator, the unsung hero of AWS AppConfig. JSON validation is like a warm blanket on a cold winter’s night, providing comfort and security. I entered the JSON schema and content, and the validator took care of the rest. It was as if I had summoned a powerful genie that effortlessly granted my JSON validation wishes.

    {
      "$schema": "http://json-schema.org/draft-04/schema#",
      "type": "object",
      "properties": {
        "phone_Login": {
          "type": "object",
          "properties": {
            "enabled": {
              "type": "boolean"
            }
          },
          "required": [
            "enabled"
          ]
        },
        "social_logins": {
          "type": "object",
          "properties": {
            "enabled": {
              "type": "boolean"
            },
            "facebook": {
              "type": "boolean"
            },
            "facebook_css_style": {
              "type": "string"
            },
            "google": {
              "type": "boolean"
            },
            "google_css_style": {
              "type": "string"
            }
          },
          "required": [
            "enabled",
            "facebook",
            "facebook_css_style",
            "google",
            "google_css_style"
          ]
        }
      },
      "required": [
        "phone_Login",
        "social_logins"
      ]
    }

You can generate the JSON Schema from https://www.liquid-technologies.com/online-json-to-schema-converter

Step 04: Deploy again, and it will work.

After using the JSON Schema Validator, I was ready to deploy my updated configuration profile. I clicked “Deploy,” and like a well-oiled machine, everything fell into place. It was as if the stars had aligned, and the universe was smiling down on me. “Success!” I thought, “AWS AppConfig and Lambda are working in perfect harmony.”

Step 05: Let’s change JSON Validator a little bit

Feeling adventurous, I decided to tweak the JSON Validator, just a tad. It was a small change, akin to adding a dash of spice to an already delicious meal. I was eager to see how this change would impact my AWS AppConfig.

    "facebook_css_style": {
      "type": "integer"
    },

Step 06: Deploy again, and it will fail.

Oh, how the mighty have fallen! With bated breath, I clicked “Deploy” once more, only to be met with failure. My heart sank, but I knew that in the grand scheme of things, this was but a minor setback. As the great Thomas Edison once said, “I have not failed. I’ve just found 10,000 ways that won’t work.” This failure only fueled my resolve to find a solution.

By following these steps and embracing both the victories and setbacks, I emerged victorious in my quest to conquer Lambda validator for AWS AppConfig. I found this experience to be an invaluable teacher, and I encourage you to venture forth and explore the world of AWS AppConfig with Lambda, AWS Application Configuration Management, and JSON validation.

For more information on this thrilling adventure, visit these safe links:

• AWS AppConfig
• AWS Lambda

Now that you’re armed with the knowledge of JSON validation and AWS AppConfig, you too can conquer the challenges that lie ahead. Remember to approach each problem with an agile mindset, learn from the giants like Google and AWS, and always keep experimenting.

In the realm of DevOps, we’re like brave explorers, charting the vast seas of technology and discovering new horizons. With containers as our vessels, we navigate through the tumultuous waters of software development and deployment, emerging stronger and wiser with each adventure.

As you embark on your own AWS AppConfig journey, remember the wise words of Albert Einstein: “The only source of knowledge is experience.” Each challenge, success, and failure is an opportunity to learn and grow. And when the going gets tough, fear not! Just imagine me, your trusty DevOps companion, cheering you on from the sidelines.