DEV Community: Karthik

First build and publish Nx expo app

Karthik — Sat, 10 Feb 2024 16:48:01 +0000

As you embark on your Expo journey, ensuring a smooth build process is crucial. Here's a step-by-step guide to performing the initial build:

Step 1: First Build and Publish

Open VSCode and Navigate to Project Folder:
Open Visual Studio Code (VSCode) and navigate to the project folder containing your Expo application.
Run eas login as Admin User:
Open the terminal in VSCode and execute the eas login command. Log in using the admin user credentials. This will authenticate your Expo account for the build process.
Run npx nx affected -t build:
Execute the command npx nx affected -t build in the terminal. Follow the interactive screen prompts and choose all default values unless specific configurations are required for your project.
Complete the Build Process:
Allow the build process to complete successfully. This step ensures that your Expo project is compiled and ready for publishing.

After this step a project with a successful build will be created in your Expo account. An apk/aab file will be created which is ready to be submitted to the app store.

Streamlining Expo Build Pipeline with Bitbucket: An Admin and Developer Guide

Karthik — Sat, 10 Feb 2024 16:36:52 +0000

Admin Setup:

Step 1: Login Using Admin Account

Begin by logging into Expo using the administrator account that will manage the organization.

Step 2: Create an Organization in Expo

Navigate to the Expo dashboard and create a new organization for your project. This organization will serve as the central hub for collaboration and development.

Step 3: Create a Robot User and Access Token

In Expo, generate a robot user to handle the automated build processes. Create an access token for this user, which will be utilized in the Bitbucket pipeline.

Step 4: Save Access Token in Bitbucket

For secure integration, save the generated access token as an environment variable (EXPO_TOKEN) in Bitbucket. This token will authenticate Expo during the build process.

Step 5: Bitbucket Pipeline YAML File

Create a Bitbucket pipeline YAML file in the root of your project. This file will define the steps for testing and building your Expo project.

Below is a sample bitbucket pipeline file to build an expo application in production profile

`image: node:18.14.0

pipelines:
branches
main:
- step:
name: Build and Deploy to Production
deployment: production
script:
- npm install -g @nrwl/cli
- npm install -g nx
- npm install -g expo-cli
- npm install
- npx nx affected:build --base=main --platform all --non-interactive --no-wait
`

Step 6: Invite Users to Organization

Invite all relevant users, including developers, to the Expo organization with read access. This ensures that they can join the organization and contribute to the project seamlessly.

Developer Onboarding:

Step 1: Sign Up to Expo

For developers, the process begins with signing up for an Expo account. This account will be linked to the organization created by the admin.

Step 2: Join the Organization

Upon signing up, developers will receive an email invitation to join the organization on Expo. Click on the provided link to join the organization and gain access to the project.

By following these steps, both administrators and developers can collaborate efficiently using Expo and Bitbucket, establishing a robust build pipeline for Expo projects.

Event-Driven Microservice – Software Architecture Pattern

Karthik — Thu, 26 Oct 2023 17:14:56 +0000

In this post I will go over Event-Driven Microservice Architecture, its benefits and a Case Study implementation of an E-Commerce application. Most modern applications are run as micro services as it provides scalability and decoupled structure. One of the core principles of a micro service architecture is Database per Service Pattern where each database will be accessed by only one service, which provides a way of atomicity.

Difficulties in Micro-services Pattern:

One major difficulty in micro-services is, in real world applications a single request cannot be served by a single micro-service, as it might need different data from multiple DB’s. The immediate option is to make inter-process communication between micro-services to make this happen. There are some consequences of doing inter-process communication.

Pitfalls In Inter-process Communication:

Module A waits for the response
Dependent Module can be down
Network delays can decrease performance
If huge data then pagination is required. This means more REST calls between process
Any Module can be under heavy load and can introduce latency.

Event-Driven Approach:

To overcome the above short coming, We can use Event-Driven approach. An event-driven microservice architecture uses events to trigger and communicate between services. An event is a state change or an action to which other services might react as per the business process. This will take us to the reactive programming model.

I will run through a real world example of an event-driven architecture implementation for a fairly simple eCommerce application workflow. The workflow is as below:

Customer Orders product through Website.
Create Temp Order and attach a transaction to order.
Payment Confirmation
Create Order
Order Dispatch from warehouse
Update Site with Product quantity(Real Time)
Order Shipped
Order Delivered

Each micro-service performs a local transaction and publishes an event which can be consumed by other dependent micro-services to act upon accordingly. The Email Service consumes all the events from Order channel. So that every status change in the order has a corresponding email notification. There is no direct inter-process communication but all communications happens through events.

With this approach we can even show real time data changes to the Users. The warehouse service sends an event after the order is dispatched. This event is consumed by the UI and the product stock is adjusted as per the data from the event.

FAT Events:

Use of fat events makes this architecture pure async. Fat events are events where messages posted to the queue contains details of the items processed or a snapshot of the latest data. This ensures the consumer doesn’t need additional API call to get the latest data from the DB.

Idempotency:

No technology is invincible, this goes for the message queue as well. There might be occurrences where the message queue does face some issues and resends the same message multiple times. So it is very important for all the consuming services to check for idempotency of the events before processing it to avoid duplicates.

One quick solution is that we can add a unique key to each event message and check for the key in all the consumer services before processing.

Outbox Pattern:

Another scenario in this architecture is messages getting lost due to Queue downtime. These become irreversible. To mitigate this, we can follow the outbox pattern where all messages are stored in DB and then processed by an event service and sent to consumers. This way even if the Queue is down the messages are still recorded and can be replayed to Queue when it is back on.

Conclusion:

In micro service architecture, we have to keep coupling low. To be able to keep the coupling low, we have to focus on the connections between modules. Also we want scalability and flexibility at will, and this can be achieved by Event-Driven approach. We can combine this architecture with power of serverless computing.

Generate Pre-Signed URL for S3 with AWS Lambda

Karthik — Tue, 24 Oct 2023 17:33:39 +0000

Step 1: Create an AWS Lambda function

Go to the AWS Lambda console.
Click Create function.
Choose Author from scratch.
Configure your function:
Function Name: Choose a name for your Lambda function.
Runtime: Select a runtime,We will use Node in this tutorial. (Node latest version).
Execution Role: Create a new role for Lambda service with permissions to access S3. This role should have an IAM policy allowing PutObject and ReadObject access to the S3 bucket. For simplicity we will choose AmazonS3FullAccess. Do not use this in production environment.
Under Advanced settings, select Enable function URL and Auth type as NONE. Leave the rest as default.
Click Create function.

Step 2: Write the Lambda function code

/* We will pass the file name in the request to the lambda 
 * function and that will be used to create the object key. If no 
 * file name is provided we will fallback to a hardcoded filename
 * for simplicity. You can throw a validation error if no filename 
 *is passed in request as query param
*/
import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
import {getSignedUrl} from "@aws-sdk/s3-request-presigner";

export const handler = async (event) => {
const region = 'your-region';
const bucket = 'your-bucket';
const queryStringParameters = event.queryStringParameters;
var key = "test";
if (queryStringParameters) {
key = queryStringParameters.filename;
}
return createPresignedUrlWithClient({region,bucket,key});
};

const createPresignedUrlWithClient = ({ region, bucket, key }) => {
const client = new S3Client({ region });
const command = new PutObjectCommand({ Bucket: bucket, Key: key });
return getSignedUrl(client, command, { expiresIn: 3600 });
};

Step 3: Create an S3 bucket

Go to the AWS S3 console.
Click Create bucket.
Enter a name for your bucket.
Select a region for your bucket.
Click Create.

Step 4: Update the CORS policy for the S3 bucket

Go to the Properties tab for your S3 bucket.
Click Edit CORS configuration.
Add the following CORS policy and Click Save. Again for simplicity we will allow all origins. But in production this has to be revisited to allow only the required origin.

[
{
"AllowedHeaders": [
"*"
],
"AllowedMethods": [
"PUT"
],
"AllowedOrigins": [
"*"
],
"ExposeHeaders": []
}
]

Step 5: Test the Lambda function

Enter the Function URL in a postman/Curl GET request with filename as query parameter.
The response will be a presigned URL that you can use to upload a file to the S3 bucket.
Upload a file using the URL in postman/Curl by choosing PUT request type.

Conclusion

In this blog post, we showed you how to create a Lambda function that generates a presigned URL for S3 upload. We also showed you how to create an S3 bucket and update the CORS policy for the bucket.