So you've taken the plunge into the exciting, yet sometimes daunting, world of freelancing. Congratulations! Now, the question becomes: how do you build a foundation of 

experience, trust, and an amazing client list

 to launch your freelance career into the stratosphere? Fear not, intrepid freelancer, for this guide will equip you with the tools you need to conquer the freelance kingdom.

Experience: From Humble Beginnings to Portfolio Powerhouse

Experience is the cornerstone of any successful freelancer. But how do you get it when you're just starting out? Don't worry, you have more options than you think!

Trust is the golden thread that binds you to your clients. Here's how to weave a tapestry of reliability:

Client List: From Strangers to Delighted Collaborators

Now, let's talk about attracting those dream clients. Here's how to turn strangers into loyal collaborators:

Remember, building a successful freelance career takes time and dedication. But by focusing on gaining experience, building trust, and attracting high-quality clients, you'll lay the foundation for a thriving freelance castle. So, go forth, conquer your freelance goals, and remember, the journey is just as exciting as the destination!

 Don't be afraid to ask for help! Join freelance communities, seek mentors, and utilize online resources. The freelance community is full of supportive individuals who want to see you succeed.

Now get out there and start building your freelance empire!

 Building Your Freelance Castle: Experience, Trust, and Clients, Oh My!

In the ever-evolving realm of technology, staying updated is not just a choice but a necessity for developers. The year 2023 is seeing a plethora of technologies and platforms gaining traction, promising opportunities and growth. Whether you are a seasoned developer or a newbie stepping into this dynamic world, here’s a comprehensive guide on the technologies that you should be learning in 2023.

, cloud computing remains at the forefront. Focus on building and deploying applications on the cloud, specializing in microservices and serverless architectures.
⁠

 for orchestrating your containers efficiently. 
⁠

 for continuous integration and deployment, while utilizing 

 for developing machine learning models, and delve into 

 tools for seamless deployment and management. 
⁠

With cybersecurity being paramount, focus on application and network security, ethical hacking, secure coding, and threat modeling. 
⁠

Edge computing is burgeoning; hence, developing skills around its frameworks and platforms is prudent. 
⁠

 remain essential. Python is particularly significant in data science and machine learning. 

Low code/no code platforms are revolutionizing rapid development, making them an essential learning area. 

13. Augmented Reality (AR) and Virtual Reality (VR):

 for developing immersive AR and VR experiences.
⁠

Venture into the basics of quantum computing and quantum programming languages such as 

With a global focus on sustainability, learning technologies that emphasize energy efficiency is crucial. 

Understanding and developing around 5G technology opens avenues for innovation.
⁠

 remain pivotal for web development, making them indispensable.
⁠

In addition to exploring these technologies and resources, joining communities, forums, and social media groups related to these topics will help you stay updated and solve any queries you might have. Keep in mind that hands-on experience through projects and real-world application of your knowledge is invaluable, so be sure to apply what you learn!

Beyond technical prowess, honing soft skills like problem-solving, communication, and teamwork is equally vital. Stay abreast with industry trends, contribute to open-source projects, and be an active participant in tech communities. In this fast-paced technological era, continuous learning and adaptation are the keys to staying relevant and unlocking new possibilities.

Navigating the Tech Landscape in 2023: A Developer’s Guide

Building a mobile app can be a daunting task, especially if you're on a tight budget. However, it's possible to build an affordable and scalable mobile app with a backend and admin area. 

Possible tech stack for an affordable mobile app and admin area:

We'll take a look at how you can use Flutter, React, Vercel, Supabase, and Firebase to build an affordable mobile app.

Flutter is a popular open-source mobile app development framework that allows you to build high-performance, beautiful mobile apps for both iOS and Android. With Flutter, you can create a single codebase that works on both platforms, which saves time and money. Flutter also offers a wide range of pre-built widgets and plugins that can be used to add functionality to your app.

React is a popular JavaScript library that allows you to build user interfaces for web applications. With React, you can create a responsive and dynamic admin area for your mobile app. The advantage of using React for your admin area is that you can reuse code and components from your mobile app, which makes it easier to maintain and update.

Vercel is a cloud platform that offers serverless deployment for web applications. With Vercel, you can host your React admin area and deploy it with ease. Vercel also offers advanced features such as automatic scaling and instant cache invalidation, which can improve the performance of your admin area.

Supabase  (Authentication, Storage, Database, and Serverless Functions)

Cost: from $25 / month / project | Self hosted option available

Supabase is an open-source backend as a service (BaaS) that offers a wide range of features, including authentication, storage, database, and serverless functions. With Supabase, you can quickly set up a backend for your mobile app without writing any server-side code. Supabase also offers an easy-to-use API that can be used to interact with your backend.

Firebase (Analytics, Crashlytics, and Push Notifications)

Firebase is a popular mobile app development platform that offers a wide range of features, including analytics, crashlytics, and cloud messaging. With Firebase, you can track user behavior and app performance, monitor crashes and errors, and send targeted messages to your users. Firebase also offers a robust set of APIs and SDKs that can be used to integrate with your mobile app.

In conclusion, building an affordable and scalable mobile app with a backend and admin area is possible. By following these steps and choosing the right tools and providers, you can build an app that meets your requirements and budget. Remember to stay focused on your app's core features and test your app thoroughly before launching it to the public. 

Building an affordable and scalable mobile app with backend and admin area

Becoming a full-stack engineer is a rewarding career path that requires a diverse set of skills in both front-end and back-end development. In this blog post, we'll outline a pathway to becoming a full stack engineer.

In conclusion, becoming a full stack engineer requires a lot of dedication and learning, but it can be a fulfilling and rewarding career. Start by learning the fundamentals of computer science, choosing a technology stack, and learning front-end and back-end development. Build a portfolio of projects, learn DevOps, and start applying for jobs once you feel confident in your skills. Good luck!

Pathway to becoming a full-stack engineer

In the modern world, businesses are constantly looking for ways to improve efficiency and streamline their processes. Artificial Intelligence (AI) and automation have become key technologies that can help businesses achieve these goals. There are many off-the-shelf AI and automation solutions available in the market, and choosing the right one can be a challenge.

Here are some of the best off-the-shelf AI and automation solutions that businesses can use to improve their operations:

These are just a few examples of the many off-the-shelf AI and automation solutions available in the market. When choosing the right solution for your business, it's important to consider your specific requirements and use case. The best solution for you will depend on the size of your business, your budget, and the specific tasks you need to automate.

In conclusion, off-the-shelf AI and automation solutions provide businesses with a fast and easy way to improve efficiency and streamline their operations. Whether you're a small or large business, there's a solution out there that can help you achieve your goals. When choosing the right solution, it's important to consider your specific requirements and use case, and to choose a solution that provides a flexible and scalable platform for AI and automation.

Best off-the-shelf AI and automation solutions

With the right support, startups can gain access to funding, mentorship, resources, and connections that can help them take their businesses to the next level. Here are some steps that can help you find the right investors or accelerator programs for your tech startup.

Finding the right investors or accelerator programs can take time and effort, but the rewards can be substantial. By researching, networking, and preparing a strong pitch, you can increase your chances of finding the right match for your tech startup.

Note: This is a general guide and might not be applicable to every scenario. It's always recommended to seek professional advice before making any major business decisions.

How to find investors or accelerator programs for tech startups

There are a lot of options when choosing the right platforms and services for building and securing your micro-services, some of the following come to mind: 

These platforms and services offer a range of features and capabilities, so it's important to choose one that aligns with your specific needs and requirements. It is also important to consider factors such as scalability, security, and cost when choosing a platform or service for building server-side microservices; In this post I will be going over getting things setup and secured with aws.
⁠

These steps provide a general guideline for building microservices in AWS. The exact implementation will depend on your specific requirements and architecture, so it is important to carefully consider your needs and plan your implementation accordingly.

A good way to set this all up is using CDK, a cloud-agnostic software development framework to define cloud infrastructure as code and provision it through AWS CloudFormation. 

In conclusion, the AWS CDK is a great choice for building microservices in AWS because it is cloud-agnostic, provides infrastructure as code, has a higher level of abstraction, speeds up development and deployment, and improves collaboration and sharing. By using the AWS CDK, you can simplify the process of building, deploying, and maintaining microservices in AWS.

An effective guide to building and securing micro-services in AWS


Building and releasing a free plugin, package, or framework can be a great way to contribute to the developer community and gain recognition for your skills. However, it's important to approach the process with a clear plan and understanding of what it takes to successfully release a free plugin, package, or framework.

Here are some tips on how to successfully build and release a free plugin, package, or framework:

In conclusion, building and releasing a free plugin, package, or framework can be a rewarding experience. By following these tips and focusing on building a stable, well-documented, and well-promoted project, you'll be well on your way to creating a successful plugin, package, or framework that benefits the developer community.

How to successfully build and release a free plugin, package or framework

Open source software has become a vital component of modern software development. Not only do open source packages, libraries, and frameworks provide developers with a wealth of pre-built functionality, but they also offer a way for developers to give back to the community and advance the state of the art.

One of the biggest benefits of contributing to open source projects is the opportunity to learn and grow as a developer. By working on open source projects, developers can gain experience with new technologies and programming paradigms, and learn from the best practices of other experienced developers. This can be especially valuable for newer developers, who may not have the same level of experience or resources as more established developers.

In addition to personal growth, contributing to open source projects can also be a great way to build a strong professional network. Open source projects often have a large community of contributors, and by participating in these projects, developers can meet and collaborate with other talented and experienced developers. This can lead to valuable connections and opportunities for future employment or collaboration.

Another benefit of contributing to open source projects is the ability to give back to the community. Open source software is built and maintained by a community of volunteers, and by contributing to these projects, developers can help ensure that the software remains free and accessible to everyone. Additionally, by contributing to open source projects, developers can help drive innovation and advance the state of the art in software development.

Finally, contributing to open source projects can also be a great way to build a strong portfolio and showcase your skills to potential employers. Many employers value experience with open source software and actively seek out candidates who have contributed to open source projects.

In summary, contributing to open source packages, libraries, and frameworks can be a great way for developers to learn, grow, connect, give back, and showcase their skills. It's a win-win situation for both the developer and the open source community. So, it is always good to contribute to open source projects and give back to the community.

Check back soon for my new post on How to successfully build and release a free plugin, package or framework


Why developers should contribute to open source packages, libraries and frameworks

Getting multiple environments setup in flutter has always been a bit if a mystery to me, I've setup multi environment setups in React Native before but somehow things seemed a bit more complex when it came to flutter. I eventually set aside a day to get it working and after following a bunch of tutorials I finally got it working.

Before I get to the setup steps its probably a good idea to know a bit about the use case for this:
⁠
⁠1. Its a flutter app that will be published for Apple and Android.
⁠2. I'm using 

Supabase

 for the authentication, database and file storage in the app
⁠3. I'm using 

 for various things such as analytics, performance monitoring, push notifications, in app messaging, remote config, in app notifications and ML. I will be using 2 different projects, one for production and one for Staging/Dev
⁠4. I'm using 

 for loggin errors and crashes
⁠5. I'm using 

 to speed up the deploy process to IOS
⁠6. My app will have 3 environments, Dev, Staging, Prod; Dev will point to a local supabase instalation for development, while staging and prod will each point to supabase cloud projects.
⁠7. I will be sending my app out for testing using testflight on ios and send out apk builds for android, I need to be able to have both apps installed at the same time so i will have separate apps created on xcode and each environment of the app will have a different name and id.
⁠
⁠⁠Now there are alreay loads of tutorials that are really good for getting things setup in Android so will be skipping those parts, but the steps i took to get this entire setup working for ios is as follows:

First of all we need to create some directories in our ios project that will house environment specifig files, GoogleServices-Info.plist in our case:

⁠ios/config
⁠     /dev
     /prod
     /staging

Add firebase dependencies and complete flutterfire setup

 that we intend on using in the app, when they've all been added and configured as the docs mention we need to run the 

 command, run the following command (Dont forget to replace the values to match your project)

flutterfire config \
 --project=YOUR_FIREBASE_PROJECT \
 --out=lib/firebase_options.dart \
 --ios-bundle-id=YOUR_IOS_BUNDLE_ID \
 --android-package-name=YOUR_ANDROID_PACKAGE_NAME

this will run you through the steps to and get your firebase accounts setup, when this file completes you will need to move the 

 files that got created into the config directory you setup in the previous step so

 /ios/config/prod/GoogleServices-Info.plist

/ios/config/prod/firebase_app_id_file.json

You will need to repeat this step for your staging and development environments you can use the same firebase project if you want, as long as the bundle ids are different it will just create new apps within the project, an example for dev would look like this. (Make sure to change the out= flag to be different from the one in your prod)

flutterfire config \
 --project=YOUR_DEV_FIREBASE_PROJECT \
 --out=lib/firebase_options_dev.dart \
 --ios-bundle-id=YOUR_IOS_BUNDLE_ID.dev \
 --android-package-name=YOUR_IOS_BUNDLE_ID.dev

Add schemes in xcode and update buildconfigs

This is the part that gets a awkward to explain but I will try my best, you will want to click on the scheme in the top panel of xcode and click on manage schemes, 

you will want to open xcode and click on Runner in the left sidebar, and open the Runner project

Screenshot 2022-09-18 at 22.39.45.png

Click on the plus button and in the dropdown choose Runner for the target, and give your scheme a name, as i have done in the photo above. You only need to do this for new environments, you can simply rename the existing runner scheme to Prod which is what i have done.
⁠
⁠Once you have created your schemes you will to create config files for each and assign them in your project info. To do this you need to duplicate the Debug and Release config files for each environment, select the default Debug config and then file -> duplicate

Screenshot 2022-09-18 at 22.43.42.png

Give each one a name as above while leaving the defaults as Debug and Release, these will be used for your prod environment. You must make sure to save the file under the ios/Flutter directory and have the Runner target checked before saving as follows.

Screenshot 2022-09-18 at 22.46.12.png

once created you want to add the following values into each of your environment configs you just created.

app_display_name=Product Name
app_env_name=Prod

app_display_name=Product Name Dev
app_env_name=Dev

app_display_name=Product Name Staging
app_env_name=Staging

⁠The next step is to assign these configs to our schemes, we can do that in the info section for our runner project.

Screenshot 2022-09-18 at 22.50.01.png

You will need to add the configurations for each of our environments and rename the default ones to our prod scheme name, by the end of it your configurations should look like this

Screenshot 2022-09-18 at 22.51.52.png

Add build step needed to copy over firebase config files

At this point you should be able able to run your app using the different environments using either excode or the 

 but we arent complete yet, we still need to tell the app to use the correct firebase config for each environment, to do that we will need to add a build phase in under like below, see 'Copy firebase config file to correct location'

Screenshot 2022-09-18 at 22.55.53.png

To add a build phase click the plus button in the top left and choose New Run Script Phase, and in the command section we want to paste in the following:


DESTINATION=${BUILT_PRODUCTS_DIR}/${PRODUCT_NAME}.app

if [ "${CONFIGURATION}" == "Debug-Prod" ] || [ "${CONFIGURATION}" == "Release-Prod" ] || [ "${CONFIGURATION}" == "Profile-Prod" ] || [ "${CONFIGURATION}" == "Release" ]; then
cp "${PROJECT_DIR}/config/prod/GoogleService-Info.plist" "${DESTINATION}/GoogleService-Info.plist"
echo "Production plist copied"
elif [ "${CONFIGURATION}" == "Debug-Staging" ] || [ "${CONFIGURATION}" == "Release-Staging" ] || [ "${CONFIGURATION}" == "Profile-Staging" ] || [ "${CONFIGURATION}" == "Debug" ]; then
cp "${PROJECT_DIR}/config/staging/GoogleService-Info.plist" "${DESTINATION}/GoogleService-Info.plist"
echo "Staging plist copied"
elif [ "${CONFIGURATION}" == "Debug-Dev" ] || [ "${CONFIGURATION}" == "Release-Dev" ] || [ "${CONFIGURATION}" == "Profile-Dev" ] || [ "${CONFIGURATION}" == "Debug" ]; then
cp "${PROJECT_DIR}/config/dev/GoogleService-Info.plist" "${DESTINATION}/GoogleService-Info.plist"
echo "Development plist copied"
fi

This will grab the correct GoogleService-Info.plist file and copy it in to the build file each time we run a build. Make sure to adjust if you have used different names for your environments.



Next thing i needed to do was setup a way that I could reference different environment values based on the current flavor, I found this from another tutorial but closed the tab and can't seem to find it again.
⁠
⁠Firstly we need to add a function into our Runner/AppDelegate.swift file, the file should look like this in the end:

import UIKit
import Flutter

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
  override func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
  ) -> Bool {
    GeneratedPluginRegistrant.register(with: self)


    let controller = window.rootViewController as! FlutterViewController

    let flavorChannel = FlutterMethodChannel(
        name: "flavor",
        binaryMessenger: controller.binaryMessenger)

    flavorChannel.setMethodCallHandler({(call: FlutterMethodCall, result: @escaping FlutterResult) -> Void in
        // Note: this method is invoked on the UI thread
        let flavor = Bundle.main.infoDictionary?["App - Flavor"]
        result(flavor)
    })

    
    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
  }
}


Update your apps Info.plist so it allows us to access the "App - Flavor" value:

<key>App - Flavor</key>
<string>$(app_env_name)</string>

Then we can finally get into some flutter code, firstly i created a config class called FlavorSettings with the following (take not of how i am pointing to the different firebase configs) :

import 'package:firebase_core/firebase_core.dart';
import 'package:peckish/firebase_options.dart' as firebase_prod;
import 'package:peckish/firebase_options_staging.dart' as firebase_staging;
import 'package:peckish/firebase_options_dev.dart' as firebase_dev;

class FlavorSettings {
  final bool debugEnabled;
  final String supabaseUrl;
  final String supabaseAnonKey;
  final FirebaseOptions firebaseOptions;

  FlavorSettings.dev()
      : debugEnabled = true,
        supabaseUrl = '',
        supabaseAnonKey = '',
        firebaseOptions = firebase_dev.DefaultFirebaseOptions.currentPlatform;

  FlavorSettings.staging()
      : debugEnabled = true,
        supabaseUrl = '',
        supabaseAnonKey = '',
        firebaseOptions = firebase_staging.DefaultFirebaseOptions.currentPlatform;

  FlavorSettings.prod()
      : debugEnabled = false,
        supabaseUrl = '',
        supabaseAnonKey = '',
        firebaseOptions = firebase_prod.DefaultFirebaseOptions.currentPlatform;
}


To get the correct flavor we need to create a function and call it in our main.dart file like so

Future<FlavorSettings> _getFlavorSettings() async {
  String? flavor =
      await const MethodChannel('flavor').invokeMethod<String?>('getFlavor');

  if (flavor == 'Dev') {
    return FlavorSettings.dev();
  } else if (flavor == 'Prod') {
    return FlavorSettings.prod();
  } else if (flavor == 'Staging') {
    return FlavorSettings.staging();
  } else {
    throw Exception("Unknown flavor: $flavor");
  }
}

final settings = await _getFlavorSettings();

// settings.supabaseUrl
// settings.firebaseOptions
// etc

Install and make changes to fastfile (Skip this if you aren't using fastlane)

The next thing i wanted to do was make sure that i could still use fastlane to help deploy ios apps to xcode that will work with each environment, to do this i used the fastlane init setup and followed the steps to setup for deploying to TestFlight, we then need to update the Fastfile and Appfile that fastlane created to be the following:

// Fastfile
⁠

⁠
default_platform(:ios)

platform :ios do
  desc "Push a new beta build to TestFlight"
  lane :beta do
    build_app(workspace: "Runner.xcworkspace", scheme: "Prod")
    upload_to_testflight
  end
  lane :beta_dev do
    build_app(workspace: "Runner.xcworkspace", scheme: "Dev")
    upload_to_testflight
  end
  lane :beta_staging do
    build_app(workspace: "Runner.xcworkspace", scheme: "Staging")
    upload_to_testflight
  end
end


// AppFile

app_identifier("APP_IDENTIFIER") # The bundle identifier of your app
apple_id("APPLE_ID") # Your Apple Developer Portal username

itc_team_id("ASC_TEAM_ID") # App Store Connect Team ID
team_id("DEV_ACCOUNT_TEAM_ID") # Developer Portal Team ID

# For more information about the Appfile, see:
#     https://docs.fastlane.tools/advanced/#appfile


for_platform :ios do
  for_lane :beta_dev do
      app_identifier 'APP_IDENTIFIER.dev'
  end
  for_lane :beta_staging do
      app_identifier 'APP_IDENTIFIER.staging'
  end
end

You can now create your apps in App Store Connect using the ids that you setup, when done you can deploy your app using 

That should be all you need to get going but feel free to reach out if you think there is anything I can add.

Hopefully this tutorial has helped you get a  multiple environment setup with firebase and custom config variables for your flutter app.

Flutter (IOS) multiple environments setup with firebase and custom config variables

A while back now I started playing around with Pythons FastApi, an easy to use extreamly performant api framework for python. I eventually had a project that was a good use case for a fast api backend. All was great with building the api but ran into some trouble figuring out how to deploy it to AWS.

To start things off lets setup our dockerfile for the project (

FROM public.ecr.aws/lambda/python:3.9

COPY ./requirements.txt ./requirements.txt

RUN python3 -m ensurepip
RUN pip install -r ./requirements.txt

RUN mkdir tmp_export_files
COPY ./app ${LAMBDA_TASK_ROOT}/app
COPY ./app/main.py ${LAMBDA_TASK_ROOT}
COPY ./app/__init__.py ${LAMBDA_TASK_ROOT}

CMD ["main.handler"]

Note: the dockerfile above assumes you are using a requirements.txt file for managing dependencies
⁠

from fastapi import FastAPI, APIRouter
from starlette.middleware.cors import CORSMiddleware
from mangum import Mangum
from app.core.router import api_router
from app.core.database import database

router = APIRouter()

app = FastAPI(title="App Name")

app.add_middleware(
    CORSMiddleware,
    allow_origins=[*],
    allow_credentials=True,
    allow_methods=["GET", "POST", "HEAD", "PUT", "DELETE", "PATCH", "OPTIONS", "*"],
    allow_headers=["Authorization", "*"],
)

app.include_router(api_router)

@app.on_event("startup")
async def startup():
    if not database.is_connected:
        await database.connect()


@app.on_event("shutdown")
async def shutdown():
    if database.is_connected:
        await database.disconnect()
        

handler = Mangum(app)



⁠
⁠This tutorial assumes you have a basic knowledge of CDK and aws services so i won't be going into full detail on how to set that up, but here is the stack ive used, you will need to change this to match the services you've used.
⁠
⁠

import * as cdk from "@aws-cdk/core";
import * as cognito from "@aws-cdk/aws-cognito";
import * as apigateway from "@aws-cdk/aws-apigateway";
import * as lambda from "@aws-cdk/aws-lambda";
import * as ec2 from "@aws-cdk/aws-ec2";
import * as s3 from "@aws-cdk/aws-s3";
import * as iam from "@aws-cdk/aws-iam";
import * as rds from "@aws-cdk/aws-rds";
import * as secretsManager from "@aws-cdk/aws-secretsmanager";
import * as ecr from "@aws-cdk/aws-ecr";

import {
  AuthorizationType,
  CfnAuthorizer,
  LambdaIntegration,
} from "@aws-cdk/aws-apigateway";
import { Duration } from "@aws-cdk/core";

export class InfrustructureStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    const buildResourceId = (suffix: string) =>
      `${id}-${suffix}`;

    super(scope, id, props);

    const vpc = new ec2.Vpc(this, buildResourceId("vpc"), {
      natGateways: 1,
    });

    const dbSubnetGroup = new rds.CfnDBSubnetGroup(
      this,
      buildResourceId("db-subnet"),
      {
        dbSubnetGroupDescription: "Subnet group to access database",
        dbSubnetGroupName: buildResourceId("db-subnet"),
        subnetIds: vpc.privateSubnets.map((s) => s.subnetId),
      }
    );

    const dbSecurityGroup = new ec2.SecurityGroup(
      this,
      buildResourceId("db-security-group"),
      {
        vpc,
        allowAllOutbound: false,
      }
    );

    const dbCredentialsSecret = new rds.DatabaseSecret(
      this,
      buildResourceId("db-secret"),
      {
        username: "dbadminuser",
      }
    );

    const dbCluster = new rds.CfnDBCluster(this, buildResourceId("db"), {
      dbClusterIdentifier: buildResourceId("db"),
      dbSubnetGroupName: dbSubnetGroup.dbSubnetGroupName,
      vpcSecurityGroupIds: [dbSecurityGroup.securityGroupId],
      engineMode: "serverless",
      engine: "aurora-postgresql",
      engineVersion: "10.12",
      databaseName: "dbname",
      masterUsername: dbCredentialsSecret
        .secretValueFromJson("username")
        .toString(),
      masterUserPassword: dbCredentialsSecret
        .secretValueFromJson("password")
        .toString(),
      backupRetentionPeriod: 1,
      scalingConfiguration: {
        autoPause: false,
        minCapacity: 2,
        maxCapacity: 2,
      },
      deletionProtection: true,
      enableHttpEndpoint: true,
    });

    dbCluster.addDependsOn(dbSubnetGroup);

    dbCredentialsSecret.attach({
      asSecretAttachmentTarget: () => ({
        targetId: dbCluster.ref,
        targetType: secretsManager.AttachmentTargetType.RDS_DB_CLUSTER,
      }),
    });

    const dbPort = ec2.Port.tcp(cdk.Token.asNumber(dbCluster.attrEndpointPort));

    const dbConnections = new ec2.Connections({
      securityGroups: [dbSecurityGroup],
      defaultPort: dbPort,
    });

    dbSecurityGroup.addIngressRule(
      ec2.Peer.anyIpv4(),
      ec2.Port.tcp(22),
      "allow SSH access from anywhere"
    );

    const userPool = new cognito.UserPool(this, buildResourceId("pool"), {
      userPoolName: buildResourceId("pool"),
      selfSignUpEnabled: true,
      accountRecovery: cognito.AccountRecovery.EMAIL_ONLY,
      userVerification: {
        emailSubject: "Verify your email address to use app",
        emailStyle: cognito.VerificationEmailStyle.CODE,
      },
      autoVerify: {
        email: true,
      },
      signInAliases: {
        email: true,
      },
      standardAttributes: {
        fullname: {
          required: true,
          mutable: false,
        },
        email: {
          required: true,
          mutable: true,
        },
      },
      signInCaseSensitive: false,
      removalPolicy: cdk.RemovalPolicy.DESTROY,
    });

    const userPoolClient = new cognito.UserPoolClient(
      this,
      buildResourceId("pool-client"),
      {
        userPool,
      }
    );

    const ecrRepository = ecr.Repository.fromRepositoryName(
      this,
      buildResourceId("ecr-repository"),
      buildResourceId("ecr-repository")
    );

    const httpLambda2Code = lambda.Code.fromEcrImage(ecrRepository, {
      tag: "latest",
      cmd: ["main.handler"],
    });

    const bucket = new s3.Bucket(this, buildResourceId("image-store"), {
      bucketName: buildResourceId("image-store"),
      removalPolicy: cdk.RemovalPolicy.DESTROY,
      autoDeleteObjects: true,
    });

    const lambdaEnvironment = {
      DATABASE_URL: `postgresql://${dbCluster.masterUsername as string}:${
        dbCluster.masterUserPassword as string
      }@${dbCluster.attrEndpointAddress}:${dbCluster.attrEndpointPort}/${
        dbCluster.databaseName as string
      }`,
      COGNITO_REGION: "eu-west-1",
      COGNITO_USERPOOLID: userPool.userPoolId,
      COGNITO_APPCLIENTID: userPoolClient.userPoolClientId,
      S3_BUCKET: bucket.bucketName,
      TMP_EXPORT_PATH: "/tmp",
      APP_ENV: "PROD",
    };

    const httpLambda2 = new lambda.Function(
      this,
      buildResourceId("lambda-http"),
      {
        functionName: buildResourceId("lambda-http"),
        memorySize: 512,
        timeout: Duration.seconds(8),
        handler: lambda.Handler.FROM_IMAGE,
        runtime: lambda.Runtime.FROM_IMAGE,
        code: httpLambda2Code,
        environment: lambdaEnvironment,
        vpc,
      }
    );

    bucket.grantReadWrite(httpLambda2);

    httpLambda2.connections.allowTo(
      {
        connections: dbConnections,
      },
      dbPort
    );

    httpLambda2.addToRolePolicy(
      new iam.PolicyStatement({
        actions: ["*"],
        resources: [userPool.userPoolArn],
      })
    );

    bucket.grantReadWrite(httpLambda2);

    httpLambda2.connections.allowTo(
      {
        connections: dbConnections,
      },
      dbPort
    );

    const migrationLambdaCode = lambda.Code.fromEcrImage(ecrRepository, {
      tag: "latest",
      cmd: ["alembic.config.main"],
    });

    const migrationLambda = new lambda.Function(
      this,
      buildResourceId("lambda-migration"),
      {
        functionName: buildResourceId("lambda-migration"),
        vpc,
        code: migrationLambdaCode,
        handler: lambda.Handler.FROM_IMAGE,
        runtime: lambda.Runtime.FROM_IMAGE,
        timeout: cdk.Duration.seconds(600),
        tracing: lambda.Tracing.ACTIVE,
        environment: lambdaEnvironment,
      }
    );

    migrationLambda.connections.allowTo(
      {
        connections: dbConnections,
      },
      dbPort
    );

    const authIntegration = new LambdaIntegration(httpLambda2);

    const apiGateway = new apigateway.LambdaRestApi(
      this,
      buildResourceId("api-gateway"),
      {
        handler: httpLambda2,
      }
    );

    const auth = new CfnAuthorizer(this, "APIGatewayAuthorizer", {
      name: buildResourceId("api-authorizer"),
      restApiId: apiGateway.restApiId,
      identitySource: "method.request.header.Authorization",
      providerArns: [userPool.userPoolArn],
      type: AuthorizationType.COGNITO,
    });

    new cdk.CfnOutput(this, "UserPoolId", {
      value: userPool.userPoolId,
    });

    new cdk.CfnOutput(this, "UserPoolClientId", {
      value: userPoolClient.userPoolClientId,
    });

    new cdk.CfnOutput(this, "ApiEndpoint", {
      value: apiGateway.url,
    });
  }
}


As you can see i have setup 2 lambda functions in that stack, one for the api and one for running migrations. Also take note of the cmds i've used for each.
⁠
⁠Now you will have to create and deploy an image to your ecs stack, if you tried to deploy your stack like this you will get an error as the lambda's are going to try and get the codebase from the ecs repo that doesn't currently exist.
⁠
Once you've deployed your stack to aws, you can now continue to setup your github actions, an example of such is as follows.

name: Deploy development changes on push to main branch

on:
  push:
    branches: [main]
env:
  AWS_ECS_REPO: REPLACE_WITH_ECS_REPO_URL:latest
  MIGRATION_LAMBDA_NAME: 
  HTTP_LAMBDA_NAME:

jobs:
  build-container-and-push-to-registry:
    name: "Build container and push to registry"
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: "Build container image"
        run: docker build -t ${{ env.AWS_ECS_REPO }} . -f Dockerfile.prod
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_DEFAULT_REGION }}
      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v1
      - name: "Push image to ECR"
        env:
          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
          ECR_REPOSITORY: REPLACE_WITH_ECS_REPO_NAME
          IMAGE_TAG: latest
        run: docker push ${{ env.AWS_ECS_REPO }}
  update-migration-lambda-and-run:
    name: "Update migration lambda and run migrations"
    runs-on: ubuntu-latest
    needs: build-container-and-push-to-registry
    steps:
      - name: "Configure AWS Credentials"
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: eu-west-1
      - uses: actions/checkout@v2
      - name: "Update migration lambda code"
        run: |
          aws lambda update-function-code --function-name ${{ env.MIGRATION_LAMBDA_NAME }} --image-uri ${{ env.AWS_ECS_REPO }} --publish
      - name: "Wait 30 seconds"
        run: |
          sleep 30
      - name: "Run migrations"
        run: |
          aws lambda invoke --function-name ${{ env.MIGRATION_LAMBDA_NAME }} --cli-binary-format raw-in-base64-out --payload '["--config=/var/task/app/alembic.ini", "upgrade", "head"]' result.json
      - name: "Display migrations result"
        run: cat result.json
  update-http-api-lambda:
    name: "Update HTTP API lambda"
    runs-on: ubuntu-latest
    needs: build-container-and-push-to-registry
    steps:
      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v1
        with:
          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
          aws-region: ${{ secrets.AWS_DEFAULT_REGION }}
      - name: "Update lambda"
        run: |
          aws lambda update-function-code --function-name ${{ env.HTTP_LAMBDA_NAME }} --image-uri ${{ env.AWS_ECS_REPO }} --publish
⁠
⁠

For the above config to work you will need to set the following secrets in github:

AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
AWS_DEFAULT_REGION

You will also need to update the env variables in the top of the file.

Feel free to reach out if you've found any issues with the above tutorial. Hopfully this has helped you with deploying a FastApi project using Lambda, Docker, Aurora, CDK & Github Actions

blog