DEV Community: Federico Navarrete

How to connect to EFS via CloudShell

Federico Navarrete — Mon, 14 Apr 2025 10:12:44 +0000

A tricky topic when trying to connect to EFS is that you need to create an EC2 instance. There is not an easy way to mount as a network drive in your local laptop. But what if your organization is somehow bureaucratic and you need a thousand approvals just to run your new EC2 locally for the first time?

A quick win is to use CloudShell and an EC2 instance directly from the AWS Console. Just follow these steps:

Create an EC2 instance with any Linux.
Create a Key.
Launch it.
Create a Bucket in S3.
Upload the Key.
Open AWS CloudShell.
Download the Key: aws s3 cp s3://MY_BUCKET/MY_KEY.pem .
Give the right permissions to the Key: chmod 400 "MY_KEY.pem"
Get your configuration from the Connect section in your EC2 instance.
Connect to your EC2 instance via SSH: ssh -i "MY_KEY.pem" ec2-user@ec2MY_CONFIGURATOIN.MY_REGION.compute.amazonaws.com
Install the Amazon EFS Client: sudo yum install -y amazon-efs-utils
Create a folder called efs — sudo mkdir efs.
Mount your EFS via its IP (you can get from the Attach button): sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport MY_IP:/ efs

And that's all, now, you can mount your EFS without needing any special permissions in your local laptop.

Notes:

If you're wondering why you can't directly connect EFS to your CloudShell, it's because they're in different VPCs. If you try to create a CloudShell with your own VPC connected, it also fails, in my experience. Perhaps this will be fixed in the future.
If your EC2 is only available via private IPs, you will need to create a CloudShell using your private VPC.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to create an ECS Service with more than one Target Group

Federico Navarrete — Fri, 03 May 2024 06:00:00 +0000

You might have used the AWS GUI to create ECS services and all went smoothly until you could not attach more than one target group. That's why you came to this blog. At the present time, it is a limitation that AWS doesn't plan to address which can be annoying when you plan to use an NLB and an ALB, at the same time.

When do you do that, you might be wondering? When you have services like Derby DB or SQLite, and you want to retain the same IP. At the present time, the only way to associate multiple target groups to a service is by using the AWS CLI. The aws ecs create-service command must be used with a JSON file as input.

Pre-requisites

The Task Definition must already exist. You need to get its ARN like: aws:ecs:eu-west-2:21334324232:task-definition/app:1
The Target Group for the HTTPS port must exist. It must be of type IP and must be associated with an ALB.
The Target Group for the TCP (1532 port, for instance) must exist. It must be of type IP and must be associated with the NLB.

Execution

Configure a JSON with your own logic and the two target groups:

{
    "serviceName": "My-Service-Name",
    "cluster": "My-Cluster",
    "taskDefinition": "aws:ecs:eu-west-2:21334324232:task-definition/app:1",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:eu-west-2:21334324232:targetgroup/ecs-defaul-app/d4as56da4s56as",
            "containerName": "my-app",
            "containerPort": 443
        },
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:eu-west-2:21334324232:targetgroup/ecs-default-app-db/4das564565eda",
            "containerName": "my-app",
            "containerPort": 1539
        }
    ],
    "serviceRegistries": [],
    "desiredCount": 1,
    "launchType": "FARGATE",
    "platformVersion": "LATEST",
    "deploymentConfiguration": {
        "deploymentCircuitBreaker": {
            "enable": false,
            "rollback": false
        },
        "maximumPercent": 200,
        "minimumHealthyPercent": 100
    },
    "networkConfiguration": {
        "awsvpcConfiguration": {
            "subnets": [
                "subnet-4das64a645a6sa454"
            ],
            "securityGroups": [
                "sg-1d2asd1a3s21a35"
            ],
            "assignPublicIp": "DISABLED"
        }
    },
    "healthCheckGracePeriodSeconds": 300,
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "ECS"
    }
}

The most important configurations:

serviceName: Your service name.
cluster: The cluster name.
taskDefinition: Your repo name.
loadBalancers: Your target groups.
awsvpcConfiguration: Where you choose your subnets and security groups. Run the following command in the AWS CLI:

aws ecs create-service --profile My-Profile --service-name "My-Service-Name" --cli-input-json file://My-JSON.json

Where:

--profile is the AWS profile that contains your credentials.
--service-name is the new name for your service.
--client-input-json is the AWS JSON logic.

And that's all that you need!

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to schedule RDS instances (start/stop) easily

Federico Navarrete — Wed, 24 Apr 2024 15:54:53 +0000

A potential game changer in AWS is to schedule when your RDS should be running since every cent that we can save is important. AWS provides some solutions also, but they create new dependencies since they use AWS Dynamo DB, which I wouldn't say is the best idea. That's why I created based on some tutorials a new one based on one Lambda only. Let's check it:

Step 1. Create an IAM policy and role for Lambda

Go to the IAM console, under Access Management in the navigation pane, and choose Policies. Then, click Create policy.

Go to the JSON tab, and enter the following policy code:

{
  "Version": "2012-10-17",
  "Statement": [
      {
          "Sid": "VisualEditor0",
          "Effect": "Allow",
          "Action": [
              "rds:DescribeDBClusterParameters",
              "rds:StartDBCluster",
              "rds:StopDBCluster",
              "rds:DescribeDBEngineVersions",
              "rds:DescribeGlobalClusters",
              "rds:DescribePendingMaintenanceActions",
              "rds:DescribeDBLogFiles",
              "rds:StopDBInstance",
              "rds:StartDBInstance",
              "rds:DescribeReservedDBInstancesOfferings",
              "rds:DescribeReservedDBInstances",
              "rds:ListTagsForResource",
              "rds:DescribeValidDBInstanceModifications",
              "rds:DescribeDBInstances",
              "rds:DescribeSourceRegions",
              "rds:DescribeDBClusterEndpoints",
              "rds:DescribeDBClusters",
              "rds:DescribeDBClusterParameterGroups",
              "rds:DescribeOptionGroups"
          ],
          "Resource": "*"
      }
  ]
}

Next, click Review Policy. In the Create Policy section choose a name like rdsstopstart.

After this, choose the option Create policy.

Now that you have the policy ready, you need to create the IAM role. In the navigation pane, choose Roles followed by clicking Create role.

For Select type of trusted entity, choose AWS service. Next, For Common use cases, choose Lambda. Then, choose Next: Permissions.

In the new screen search for and select the policy you created before rdsstopstart.

Go to the last screen and for the Role name, enter rdsLambda. Then click Create role.

Step 2. Create your Lambda function to stop the database

For this section, you need to create one Lambda function that will stop and start the databases. On the Lambda console, choose Functions in the navigation pane and select Create function.

For Function name, enter rds-scheduler.
For Runtime, choose Python 3.12+.
For Execution role, select Use an existing role.
For Existing role, choose the role you created (rdsLambda).

After this, choose to Create function. On the function details page, go to the function code and replace the sample code with the following one:

import boto3
import os

def lambda_handler(event, context):
    region = os.environ['REGION']
    key = os.environ['KEY']
    value = os.environ['VALUE']

    action = event.get('action')

    if action not in ['start', 'stop']:
        print('Invalid action specified. Please provide either "start" or "stop".')
        return

    client = boto3.client('rds', region_name=region)

    def handle_rds_instances():
        response = client.describe_db_instances()
        v_read_replica = []

        for i in response['DBInstances']:
            read_replica = i['ReadReplicaDBInstanceIdentifiers']
            v_read_replica.extend(read_replica)

        for i in response['DBInstances']:
            if i['Engine'] not in ['aurora-mysql', 'aurora-postgresql']:
                if i['DBInstanceIdentifier'] not in v_read_replica and len(i['ReadReplicaDBInstanceIdentifiers']) == 0:
                    arn = i['DBInstanceArn']
                    resp2 = client.list_tags_for_resource(ResourceName=arn)

                    if 0 == len(resp2['TagList']):
                        print('DB Instance {0} is not part of autoshutdown'.format(i['DBInstanceIdentifier']))
                    else:
                        for tag in resp2['TagList']:
                            if tag['Key'] == key and tag['Value'] == value:
                                if action == 'start':
                                    start_instance(i)
                                elif action == 'stop':
                                    stop_instance(i)
                            elif tag['Key'] != key and tag['Value'] != value:
                                print('DB instance {0} is not part of autoshutdown'.format(i['DBInstanceIdentifier']))
                            elif len(tag['Key']) == 0 or len(tag['Value']) == 0:
                                print('DB Instance {0} is not part of autoShutdown'.format(i['DBInstanceIdentifier']))
                elif i['DBInstanceIdentifier'] in v_read_replica:
                    print('DB Instance {0} is a Read Replica.'.format(i['DBInstanceIdentifier']))
                else:
                    print('DB Instance {0} has a read replica. Cannot shutdown & start a database with Read Replica'.format(i['DBInstanceIdentifier']))
            else:
                for tag in resp2['TagList']:
                    if tag['Key'] == key and tag['Value'] == value and i['MultiAZ']:
                        if action == 'start':
                            start_aurora_cluster(i['DBInstanceArn'])
                        else:
                            stop_aurora_cluster(i['DBInstanceArn'])

    def start_instance(instance):
        if instance['DBInstanceStatus'] == 'available':
            print('{0} DB instance is already available'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'stopped':
            client.start_db_instance(DBInstanceIdentifier=instance['DBInstanceIdentifier'])
            print('Started DB Instance {0}'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'starting':
            print('DB Instance {0} is already in starting state'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'stopping':
            print('DB Instance {0} is in stopping state. Please wait before starting'.format(instance['DBInstanceIdentifier']))

    def stop_instance(instance):
        if instance['DBInstanceStatus'] == 'available':
            client.stop_db_instance(DBInstanceIdentifier=instance['DBInstanceIdentifier'])
            print('Stopped DB instance {0}'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'stopped':
            print('DB Instance {0} is already stopped'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'starting':
            print('DB Instance {0} is in starting state. Please stop the cluster after starting is complete'.format(instance['DBInstanceIdentifier']))
        elif instance['DBInstanceStatus'] == 'stopping':
            print('DB Instance {0} is already in stopping state.'.format(instance['DBInstanceIdentifier']))

    def stop_aurora_cluster(cluster_arn):
        """Stops an Aurora cluster identified by ARN if tagged for shutdown."""
        client.stop_db_cluster(DBClusterIdentifier=cluster_arn)
        print(f"Stopped Aurora Cluster with ARN: {cluster_arn}")

    def start_aurora_cluster(cluster_arn):
        """Stops an Aurora cluster identified by ARN if tagged for shutdown."""
        client.start_db_cluster(DBClusterIdentifier=cluster_arn)
        print(f"Started Aurora Cluster with ARN: {cluster_arn}")

    handle_rds_instances()

Then click Save.

The function needs a couple of parameters that you can configure in the Configuration tab. You need to navigate to the Environment variables section. The variables are:

KEY: it's a tag name that you would choose like SNOOZE or DEV-TEST.
REGION: the DB location like us-east-1 or eu-west-1.
VALUE: the tag value like Auto-Shutdown or true.

Then, go to the Test tab

And replace the Event JSON with one of the following options:

{ "action": "start" } => We will share this option in EventBridge to start the tagged DBs.
{ "action": "stop" } => We will share this option in EventBridge to stop the tagged DBs.

Navigate to your RDSs and tag your DB:

Then click on Test. If all is successful you will see a screen like the following one:

Step 3. Create your Amazon EventBridge Schedulers

Amazon EventBridge schedulers will trigger the Lambda function to start or stop the databases based on the schedules you defined. You will need to create two, one to start and one to stop the DBs.

In the Schedule pattern, you define the time choosing a Recurring schedule:

Then, you click Next. In the Target Detail, you choose AWS Lambda:

In the Invoke section, you choose your Lambda function like rds-scheduler:

And also you configure your Payload with:

{ "action": "start" } => We will share this option in EventBridge to start the tagged DBs.
{ "action": "stop" } => We will share this option in EventBridge to stop the tagged DBs.

After that click and choose Skip to review and create schedule. On the new page, click Create schedule.

After this, you can repeat the process for the stop scheduler. This is all that you need to schedule your RDSs.

Note:
Thanks to Yesh Tanamala, Sharath Lingareddy, and Varun Mahajan for starting this process that I improved.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to connect your SQL Server RDS to your Self Managed Active Directories (Windows Authentication)

Federico Navarrete — Fri, 22 Mar 2024 08:31:46 +0000

Enabling Windows Authentication seems like an easy deal, you only need to configure some info that your organization must provide you:

Fully qualified domain name. It's often a URL like microsoft.com
Domain organization unit. It will look like this: OU=AWS_ACCOUNT_NAME,OU=A_NUMBER,DC=YOUR_ORGANIZATION
Authorization secret ARN. The Active Directory credentials (user and password).
Domain organization unit. Some range of IPs.
Secondary DNS. Another range of IPs.

However, the tricky part is to configure the secret since it's unclear. The first part is to Store a new secret.

Then, you need to choose, Other type of secret:

You need to store the following keys:

CUSTOMER_MANAGED_ACTIVE_DIRECTORY_USERNAME: Your AD user.
CUSTOMER_MANAGED_ACTIVE_DIRECTORY_PASSWORD: Your AD password. After you have created the secret, you must make some changes to the Resource permissions section.

Search for the Principal section and secure the RDS info is there:

"Principal" : {
      "Service" : "rds.amazonaws.com"
}

After this is done, check if the Condition section exists and if not, modify it like this:

"Condition" : {
  "StringEquals" : {
    "aws:sourceAccount" : "YOUR_AWS_ACCOUNT_ID"
  },
  "ArnLike" : {
    "aws:sourceArn" : "arn:aws:rds:YOUR_REGION:YOUR_AWS_ACCOUNT_ID:db:*"
  }
}

Where:

The aws:sourceAccount is your AWS account ID.
The aws:sourceArn is the one that enables the RDS that can have access to your secret. In this example, I gave access to all DBs inside our AWS account by using the *.

This should be enough to enable you to access your Self Managed Active Directory.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to fix the Cloudwatch log stream: ResourceNotFoundException error from ECS

Federico Navarrete — Thu, 14 Mar 2024 13:54:09 +0000

Probably, if you are reading this article, you are facing the following bug after you've run a Task or Service in ECS:

ResourceInitializationError: failed to validate logger args: create stream has been retried 1 times: failed to create Cloudwatch log stream: ResourceNotFoundException: The specified log group does not exist. : exit status 1

This is happening because your task doesn't have permission to create the CloudWatch Log. To fix it, you must make changes using the JSON format definition. The first one is to add the following line in the logConfiguration section:

"awslogs-create-group": "true"

It will look like this:

"logConfiguration": {
    "logDriver": "awslogs",
    "options": {
        "awslogs-create-group": "true",
        "awslogs-group": "/YOUR_CLOUD_WATCH_LOCATION",
        "awslogs-region": "YOUR_AWS_REGION",
        "awslogs-stream-prefix": "ecs"
    }
}

The second change, you must add a new inline policy to the role that is running your task (check in the Task definition).

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup"
            ],
            "Resource": "*"
        }
    ]
}

That's all that you need. After you make these changes, your task or service should start running as expected.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

Can you make your website green 🌳♻🌳?

Federico Navarrete — Thu, 29 Feb 2024 16:31:10 +0000

Did you know that any website (including yours) produces CO₂ ⛽🤔?

A couple of years ago, we interviewed Xavier Vásquez: The Future of Research

Xavier shared with us that he was analyzing the electricity consumed ⚡ by every app we ran on our devices 💻📱.

Indeed, every swipe in Tinder or Bumble 💘 affects the environment 🌍, so be careful how often you swipe!

Coming back to the serious part, last year before COP 28 ⛽, I saw a considerable trend of companies and startups offering new solutions that could "help" you become more sustainable ♻.

I felt them like buzzwords since I saw even politicians moving from their previous roles to become "ecopreneurs" only to have a spot at COP 28. No harsh feelings, but I felt most of these initiatives were trying to profit from the UN event, not trying to save our planet.

That's why, I decided to wait until the hype was over to analyze some solutions. I was particularly curious about the ones provided for supporting websites' eco-transformations. Before 2017, I was mainly a backend developer, but after I got into web development heavily. That's why I wanted to test these websites' carbon footprint calculators:

Website Carbon Calculator v3
Greenpixie | Website Carbon Calculator
Carbon Calculator (websiteemissions.com)
Welcome – Beacon (digitalbeacon.co)
The best and most complete is Ecograder

Most solutions were not exactly very helpful since their suggestions were vague:

Your website consumes 88% more CO₂ than the others we have analyzed!
Your website produces 2.88g per visit! It's a bunch per year.
Ups, you're not running on a Green Hosting!
Your images or code are not optimized!

That pretty much summarized their results (if you didn't pay for an audit). I even requested an audit from another provider, and the results were not better.

Ecograder, on the other hand, gave me extremely valuable insights, Ecograder report:

Ecograder report

Potential improvements

Thanks to Ecograder, I learned the following 14 lessons:

To make my website more efficient and beautifully crafted on every device, watch, mobile, tablet, desktop, etc, with minimal impact on its performance.
To create custom Icon Fonts. It reduced the complexity of my website and improved its accessibility.
To identify where I had some technical debt (unused code).
To use modern code. I used too much legacy code that was convoluted and complex. In short words, heavy.
To prioritize which Images I can compress and resize and which I cannot.
To remove plugins that never worked.
To use modern image formats like WebP instead of JPG or PNG only.
To resize images to their appropriate sizes.
To lazy load images that are not visible (to scroll to see them).
To reduce the amount of calls to the hosting. I tried reaching a maximum of ten by combining some files into one.
To use dark themes. I already used them since I like them more, but it was a nice knowledge to acquire.
To load scripts dynamically until the website is fully loaded.
To lazy load images in internal invisible iFrames.
To use CDNs (Content Delivery Networks) whenever you must use full 3rd party libs like Bootstrap or jQuery.

Can this be automated? It seems like a lot of work ...

Indeed, it's tons of work. Some parts can be automated, and some parts cannot be fully automated. Also, there are several considerations if you want to go as green as possible. Let's analyze some of them:

Ecograder can help you identify which JS or CSS files have extra code. CSS can be "cleaned" with PurgeCSS. But JS is more complex and might involve a lot of re-engineering. Also, most solutions will suggest you remove Google Analytics (I highly doubt you want to do it).

Google Analytics

Generative AI solutions like GitHub Copilot or ChatGPT might help you find code improvement points, but they are bulletproof and a small change can break too many things. I used them to refactor some sections of my code, but it was a mess.
Modern solutions like SPA (Single Page Applications) will be more efficient in new cases (mainly for complex websites) since you will make fewer calls to the server and the code is cleaner and nicer. However, if you didn't build your website with these solutions and your budget is tight, you must consider a different process. Additionally, SPAs are not always so great at handling unused 3rd party CSS files since you would need to do some magic with PurgeCCS.
PNG/JPG images can be auto-converted into WebP via APIs. Also, some APIs can resize and compress them automatically. So, you have the full package. However, you must be very careful with your brand images. Any image that is at the beginning, should never be pixelated. Heavily automated optimizations might damage them if you don't exclude them.

Unoptimized brand image

Changes in your website can be detrimental. No website is static, your brand evolves, you change over the years, etc. If your new image or text is large or heavy, it might have a bigger impact on your score.
Moving to a Green Hosting might have considerable consequences if you don't know its architecture. As a hosting user, you often have monthly or yearly contracts, so you cannot easily change it overnight. Additionally, what if you move it to a service that is not poorly accessible from a farther location? Let's say you have new clients from India, you are located in Sweden, and your new green hosting is in Ireland. Your website might become slow since it's far from India. This will be hard to optimize if you don't know about software architecture and your new providers don't have edge locations near India.
The calculators don't analyze each scenario. My website has four different user experiences: Desktop, Mobile, Tablets, and Watches. Each experience has specific UIs and optimized images. Therefore, I don't think my website will produce the same amount of CO₂ if a user accesses it from their mobile as from their desktop.

Is there anything else I did and didn't mention? Indeed, I "lazy" loaded sections based on the user's scroll location. However, this might or might not benefit your impact since the calculators analyze the full loading, not only the first impression. I see it as nice to have, but might not be as eco-friendly as we think. I might need to have a longer research to analyze its results.

This pretty much summarized my experiment to transform my website into a Green one ♻. The best result I got yesterday (Feb 15th, 2024) in the 1st solution:

federiconavarrete.com

I was able to move from D to B. The only greater improvement I could make was to switch hosting providers. However, that's something I wouldn't do. For now, GitHub is transitioning to be a Green company for 2025 and be carbon-negative for 2030. So, they are already on the way. I can wait for a little longer.

Hopefully, this article can help you in your Digital Ecotransformations and bring the best of them to your websites.

Update 2024-02-28:

I reached an A in the Website Carbon Calculator after some adjustments without a Green Hosting:

Website Carbon results

Update 2024-04-11:

I reached an A in the Ecograder after several adjustments without a Green Hosting:

Ecograder results

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

Is Xamarin Dead?

Federico Navarrete — Wed, 17 Jan 2024 10:42:19 +0000

The short answer is No, it's not dead. The long explanation starts here.

A couple of days ago, I had a quite heated conversation on Twitter:

At the beginning of my career building mobile apps, I was also confused about what was Xamarin? Was it a multi-platform solution or was it a single-platform solution? The answer was both.

With Xamarin at the present time, you can build apps for:

Android only AKA Xamarin.Android,
iOS only AKA Xamarin.iOS.

Xamarin.Forms was the cross-platform solution that was replaced by MAUI.NET (more about it later).

In my case, I started to build straightaway Android apps only since I didn't own a Mac (I still don't), and that's how I easily understood the difference between the 3 solutions. However, I noticed that this confusion still persists in 2024, and that's why I wanted to bring you this short explanation:

Xamarin.Android is a platform for building native Android apps with C# that only works on Android. These are some important points about it:

The code can be compared with using Kotlin or Java.
Kotlin or Java code can be reconverted to C#.
You can reuse the typical XMLs to create your activities or views.
It generates only .apk or .abb.
It can be used to bind Android libraries from Gradle.
The final app will be more optimal and smaller since it works only on Android.
Most code might not be compatible with Xamarin.iOS.

You can read more at:

Its official GitHub repository is:
xamarin/xamarin-android

Its official documentation:
Xamarin.Android - Xamarin

Xamarin.iOS is a platform for building native iOS apps with C# that only works on iOS. These are some important points about it:

The code can be compared with using Swift or Objective C.
Swift or Objective C code can be reconverted to C#.
You can reuse Storyboards to create your views.
It generates only .ipa.
It can be used to bind iOS libraries.
The final app will be more optimal and smaller since it works only on iOS.
You must own a Mac either physically or in a cloud to compile your code.
Most code might not be compatible with Xamarin.Android.

You can read more at:

Its official GitHub repository is:
xamarin/xamarin-macios

Its official documentation:
Xamarin.iOS - Xamarin

Furthermore, there is a variation for building macOS apps only that is called Xamarin.Mac:
Xamarin.Mac - Xamarin

Credits: Microsoft

.NET MAUI is a platform for building native multiplatform apps for Android, iOS, Windows, etc. from one source code. It is the official Xamarin.Forms' evolution. These are some important points about it:

It can be compared with React Native, Flutter, or NativeScript.
Some Android, Windows, and/or iOS code/libs might be compatible but they should be readapted per platform.
It generates .akp, .abb, .exe .ipa, .app, etc.
The UI might be less flexible since it must work on all devices.
The final app will be less optimized and bigger since it works on multiple platforms.
You must also own a Mac either physically or in a cloud to compile your code for iOS and/or macOS.

You can read more at:

Its official GitHub repository is:
dotnet/maui: .NET MAUI

Its official documentation:
.NET MAUI

Hopefully, this short explanation can support you in your adventure as a mobile developer and avoid confusion. The better you know which tech you must choose, the better performance you will get and the better your results will be.

Follow me on:

LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to add Google Translate to your website

Federico Navarrete — Mon, 23 Jan 2023 19:00:00 +0000

Sometimes you would like to add to your website a quick widget to allow your users to translate into their language. Google has a simple widget that you can add with some lines of code:

<script>
    function googleTranslateElementInit() {
        new google.translate.TranslateElement(
            //here you add the supported languages like en, es, zh, nl, de, etc.
            {pageLanguage: 'en'},
            'google_translate_element'
        );
    }
</script>
<script src="https://translate.google.com/translate_a/element.js?cb=googleTranslateElementInit"></script>

<div id="google_translate_element"></div>

And that's all.

Follow me at:

LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to Update EventBridge Schedules with Lambdas

Federico Navarrete — Mon, 16 Jan 2023 10:04:31 +0000

The EventBridge is a potent tool in AWS that can help us automate our tasks. However, when you need to have dynamic schedules, it can be tricky.

First of all, the Boto3 is not the latest running on Lambdas. The current available for Python 3.9 on Jan 16, 2023, is 1.20.32 (print(boto3.__version__)), and the latest released is 1.26.50:
https://github.com/boto/boto3

Therefore, you have to do the extra steps to zip it and add it as a layer:

Install boto3 to /python directory
$ pip install boto3 -t ./python
Zip it
$ zip -r layer.zip ./python
Upload it to AWS as a Layer and configure it:
https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html

After you have done this, you need to create a Lambda function with a similar code to the one I'm sharing:

import json
import boto3

from datetime import datetime, timedelta

scheduler_client = boto3.client('scheduler')

#schedule the EventBridge Schedule to run 5 min from now
schedule_time = datetime.now() + timedelta(minutes=5)

#these values come from the EventBridge schedule itself
event_scheduler_name = 'MY_EVENT_NAME'
target_arn = 'MY_TARGET_ARN'
role_arn = 'MY_ROLE_ARN'

def lambda_handler(event, context):

    scheduler_client.update_schedule(Name=event_scheduler_name,
                                     ScheduleExpression=f'cron({schedule_time.minute} {schedule_time.hour} {schedule_time.day} {schedule_time.month} ? {schedule_time.year})',
                                     FlexibleTimeWindow={
                                        'MaximumWindowInMinutes': 1,
                                        'Mode': 'FLEXIBLE'
                                     },
                                     Target={
                                         'Arn': target_arn,
                                         'RoleArn': role_arn
                                     })

    return {
        'statusCode': 200,
        'body': json.dumps('Working!')
    }

The tricky values, the ARN and the RoleArn, come from the EventBridge Schedule:

Now, you're ready to create dynamic schedules with Python.

Banner credits:

Boyney123

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

From WebView to WebView2 in UWP

Federico Navarrete — Sun, 16 Oct 2022 09:18:51 +0000

In the old days, accessing a local website in UWP was relatively easy. Even if you wanted to load your third-party libs. The basic code you required:

The WebView:

<WebView x:Name="webView1" Source="ms-appx-web:///Assets/index.html" NavigationStarting="WebView1_NavigationStarting" NavigationCompleted="WebView1_NavigationCompleted" />

Here you defined the Source and some extra events like NavigationStarting or NavigationCompleted for loading your JS or enabling JS interaction with your third-party lib (that you had to add as a reference in your main project).

Loading your third-party lib:

private void WebView1_NavigationStarting(WebView sender, WebViewNavigationStartingEventArgs args)
{
    sender.AddWebAllowedObject("CallJSCSharp", new CallJSCSharp());
}
Adding extra code to load additional JS:

private async void WebView1_NavigationCompleted(WebView sender, WebViewNavigationCompletedEventArgs args)
{
    string filename = $"ms-appx:///Assets/js/lang/en.json";
    StorageFile file = await StorageFile.GetFileFromApplicationUriAsync(new Uri(filename));
    string contents = await FileIO.ReadTextAsync(file);

    string[] arg = { contents };

    _ = await webView1.InvokeScriptAsync("UpdateData", arg);
}

And this is the function to execute extra functions from my app:

namespace CallJSInterface
{
    private Windows.System.Display.DisplayRequest _displayRequest;

    public sealed partial class CallJSCSharp
    {
        public void KeepScreenOn()
        {
            //create the request instance if needed
            if (_displayRequest == null)
            {
                _displayRequest = new Windows.System.Display.DisplayRequest();
            }

            //make request to put in active state
            _displayRequest.RequestActive();
        }
    }
}

Load Website

Now, what are all the changes required for the new WebView2? There are several changes to be considered. The first one is to download the lib Microsoft.UI.Xaml from NuGet in your main project:

This lib allows you to add WebView2. It requires two changes:

Add this lib in your XAML's libs:

xmlns:controls="using:Microsoft.UI.Xaml.Controls"

And then, you can add your WebView2:

<controls:WebView2 x:Name="webView1" NavigationCompleted="WebView1_NavigationCompleted" />

Now comes the tricky parts. The first change is about the Source. With WebView2, we can only load external websites like bing.com or facebook.com. Any local website is going to fail.

The new approach follows creating an asynchronous function that creates a virtual host (it has to be called in the Constructor), where you map your current local website like this:

private CoreWebView2 core_wv2;

private async void LoadLocalPage()
{
    string fakeDomain = "myapp.something";
    string assetsLocation = "Assets";
    string firstPage = "index.html";

    await webView1.EnsureCoreWebView2Async();
    core_wv2 = webView1.CoreWebView2;
    if (core_wv2 != null)
    {
        core_wv2.SetVirtualHostNameToFolderMapping(
            fakeDomain, assetsLocation,
            CoreWebView2HostResourceAccessKind.Allow);

        webView1.Source = new Uri($"https://{fakeDomain}/${firstPage}");
    }
}

Every path that you have in your old app looks like this:

ms-appx-web:///Assets/

must be changed to:

https://myapp.something/

Therefore, if you loaded Bootstrap like this:

ms-appx-web:///Assets/css/boostrap.min.css

Now, it is going to be like this:

https://myapp.something/css/bootstrap.min.css

Invoke 3rd-party Libs from JS

The next part is how to interact with your third-party lib, and this part is complicated.

The first part involves adding a new and very specific C++ project, Windows Runtime Component (C++/WinRT), to your solution that must be called WinRTAdapter.

You must install a lib from NuGet Microsoft.Web.WebView2:

Add as a reference your third-party lib.

Go to your C++ project properties go to Common Properties and choose WebView2:

Here you have to do four changes:

Set Use WebView2 WinRT APIs to No.
Set Use the wv2winrt tool to Yes.
Set Use Javascript case to Yes.
Edit Include filters and add the following ones:

Windows.System.UserProfile
Windows.Globalization.Language
CallJSInterface

CallJSInterface is the name of my third-party's namespace.

You click on OK and build your C++ lib.

After you have built your C++ lib (WinRTAdapter), you must add it to your main project as a reference.

Now, we need to do some changes to be able to invoke the functions from our third-party lib. The first one is to register it. We do it in the same LoadLocalPage() function from before or on NavigationCompleted:

var namespacesName = "CallJSInterface";
var dispatchAdapter = new WinRTAdapter.DispatchAdapter();
core_wv2.AddHostObjectToScript(namespacesName, dispatchAdapter.WrapNamedObject(namespacesName, dispatchAdapter));

Where CallJSInterface is your namespace. After this, you need to register your function in your JS like this:

var callJS;
if (chrome && chrome.webview) {
    chrome.webview.hostObjects.options.defaultSyncProxy = true;
    chrome.webview.hostObjects.options.forceAsyncMethodMatches = [/Async$/];
    chrome.webview.hostObjects.options.ignoreMemberNotFoundError = true;
    window.CallJSInterface = chrome.webview.hostObjects.sync.CallJSInterface;
    callJS = new CallJSInterface.CallJSCSharp();
}

Where CallJSInterface is one more time your namespace. Now, you can invoke JS like this (the async() is mandatory):

callJS.async().KeepScreenOn()

Inject JS code

The last part is how to load your scripts as before. The old function InvokeScriptAsync("UpdateData", arg) doesn't exit. The best way is to create a class Extension like this:

public static class Extensions
{
    public static async Task<string> ExecuteScriptFunctionAsync(this WebView2 webView2, string functionName, params object[] parameters)
    {
        string script = functionName + "(";
        for (int i = 0; i < parameters.Length; i++)
        {
            script += JsonConvert.SerializeObject(parameters[i]);
            if (i < parameters.Length - 1)
            {
                script += ", ";
            }
        }
        script += ");";
        return await webView2.ExecuteScriptAsync(script);
    }
}

Now, from the NavigationCompleted, you can load it in the old way:

 _ = await webView1.ExecuteScriptFunctionAsync("UpdateData", arg);

With all these steps, you can do it again your entire process.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

Banner credits:

The Windows Club

How to disable printing on a website

Federico Navarrete — Mon, 19 Sep 2022 09:05:32 +0000

Sometimes, we have some projects where the content is sensitive or should be protected for privacy reasons or copyrights. A quick solution involves:

To prevent the key combination Ctrl + P (for printing) via JS.
To prevent text selecting and copying text via JS.
To hide the whole page on printing via CSS.

<script>
    //Prevents Ctrl + P
    //From https://stackoverflow.com/a/47848090/1928691
    window.addEventListener('keydown', function(event) {
        if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event.shiftKey || window.chrome || window.opera)) {
            event.preventDefault();
            if (event.stopImmediatePropagation) {
                event.stopImmediatePropagation();
            } else {
                event.stopPropagation();
            }
            return;
            }
    }, true);

    //Disables text selection and copying
    //From https://gist.github.com/pbaruns/a24ad79b027956ed5d77fd3e6c201467
    if (typeof document.onselectstart != "undefined") { 
        document.onselectstart = new Function ("return false");
    } 
    else { 
        document.onmousedown = new Function("return false"); 
        document.onmouseup = new Function("return true");
    }
</script>

<style>
    /*From https://stackoverflow.com/a/3359980/1928691*/
    @media print {
        html, body {
            display: none;  /* hide whole page */
        }
    }
</style>

Is it perfect? Of course, is not.

You might need to add a paywall to prevent its access.
You might need to add a DRM solution to prevent screenshots (that are often followed by OCRs to extract their text). Udemy does this already, you cannot take screenshots from several videos. You can take them if you use Firefox or less common browsers.
You will create accessibility issues.
The reader mode often bypasses common restrictions.
Some people can bypass it using the Dev Console and copy the text from the tags (Devs, RPAs, or geeks mainly?).
You might need to encrypt the text using a DRM service for anyone using the Dev Console.

This is just a quick solution that can support you in your journey.

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories

How to access EFS folders from the Windows File Explorer using WSL2

Federico Navarrete — Tue, 30 Aug 2022 10:16:00 +0000

EFS is the default place for storing your volumes when you use Fargate and ECS in AWS. This is fine when your main workstation is any Linux distro, but what happens when you work in Windows?

The easy option is to use Windows Subsystem for Linux (Ubuntu, in my case) and mount your EFS:

sudo mount -t nfs4 -o rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport MY_IP_ADDRESS:/ efs

This is fine if you just want to access your files or folders from your console, and you don't need to do anything more complex with them. However, if you want to map it as a "regular" Network Drive and/or access it from the Windows File Explorer can be tricky. This is how I accomplished it:

Step 1. Create your efs folder in this location /mnt/wsl.
Step 2. Mount your efs using the previous command.
Step 3. Go to this location \\wsl$ in the File Explorer, and get your Distro's root. In my case, \\wsl$\Ubuntu

Step 4. Copy your Distro's path and map it as your new Network Drive in Windows:

And that's all. Now you can access your EFS from your Network Drive, for example, Z:\mnt\wsl\efs

Follow me on:

Personal	LinkedIn	YouTube	Instagram	Cyber Prophets	Sharing Your Stories