kubectl run nginx --image=nginx --port=80
kubectl run nginx --image=nginx --port=80 --expose=true
kubectl run nginx --image=nginx --labels="app=web,tier=frontend"

kubectl create deployment nginx --image=nginx
kubectl create deployment nginx --image=nginx --replicas=3
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > nginx-deploy.yaml

kubectl expose pod redis --port=6379 --name=redis-service
kubectl expose pod redis --port=6379 --name=redis-service --selector="app=redis"
kubectl expose deployment nginx --port=80 --type=ClusterIP
kubectl expose pod nginx --port=80 --type=NodePort

kubectl get pods -l tier=frontend
kubectl get deploy -o wide
kubectl get endpoints redis-service

kubectl label pod nginx app=web

Scaling and Editing

kubectl scale deployment nginx --replicas=5
kubectl edit deployment nginx
kubectl delete pod nginx-xxxx

Rolling Updates

kubectl set image deployment/myapp-deployment nginx=nginx:1.25
kubectl rollout status deployment/myapp-deployment
kubectl rollout history deployment/myapp-deployment
kubectl rollout history deployment/myapp-deployment --revision=3
kubectl rollout undo deployment/myapp-deployment
kubectl rollout pause deployment/myapp-deployment
kubectl rollout resume deployment/myapp-deployment

ConfigMaps and Secrets

kubectl create configmap app-config \
  --from-literal=APP_COLOR=blue \
  --from-literal=APP_MODE=prod

kubectl create configmap app-config --from-file=application.properties
kubectl create configmap app-config --from-env-file=app.env

kubectl create secret generic app-secret --from-literal=DB_HOST=mysql
kubectl create secret generic app-secret --from-file=application.properties

Authorization & RBAC

kubectl auth can-i create deployment
kubectl auth can-i delete nodes
kubectl auth can-i create deployments --as dev-user
kubectl auth can-i create pods -n dev
kubectl auth can-i get pods --as system:serviceaccount:dev:my-sa

Others

kubectl get clusterrole --no-headers | wc -l
# Ingress
kubectl create ingress ingress-test --rule="payment.xyz.com/pay*=pay-service:80" --annotation nginx.ingress.kubernetes.io/rewrite-target=/
# ApiGroups
kubectl api-resources

Prerequisites:

1. Application deployed in AWS Elastic Beanstalk using Application Load Balancer
2. A Custom Domain and access to DNS settings

Adding custom domain

As you can see, demo-application is the name of the application currently deployed. It's a simple Spring Boot application with /api/v1/test endpoint that returns Hello world as a response. Let's see it.

Cool, the application is working. Now, let's try to add a custom domain first to this application. We need to use the Route53 service from AWS to create a hosted zone.

Steps:

• Search the Route53 service and go to the dashboard.
• Click on create hosted zone. Enter the domain you want to link to this ELB. The type would be Public hosted zone.

• Click on Create hosted zone.
• After it is created, click on Create record button.

• Toggle the Alias button and in the Choose endpoint select option, choose Alias to Elastic Bean Stalk Environment. After that, choose your region and environment. It looks something like this.

• Click create a record.

Now you need to update your nameservers in your domain provider. In my case, it's Google Domain. Head to the DNS settings page and choose custom name servers.

If you're wondering where did I get those values from, do not worry, it's from the hosted zone dashboard from AWS.

It might take few hours to days depending on your domain provider. Now, when I go to startpeeq.com/api/v1/test I can see a hello world response.

Adding SSL

If I try to curl the API with HTTPS, it responds time out because it is not enabled. Let's add the certificate now.

• Go to AWS Certificate Manager service and click on Request a public certificate.

• Enter the domain name (startpeeq.com in my case) and click on Next.
• Now comes a validation step where we need to validate that we own this domain. We have two methods of doing it i.e DNS Validation and Email Validation. I chose DNS Validation. I have to create a CNAME Record by clicking on Create Record in Route 53. We are using custom DNS nameservers from the hosted zone. So, it will create a cname record in the hosted zone recordset.

If you choose Email Validation instead, you will receive an email with a link in emails from your domain provider and you have to click on that link.

After few minutes, you will see the status issued in AWS Certificate Manager. Something like this

• Go to your Elastic Beanstic Beanstalk application and click on configuration on the left and edit the load balancer configuration. On the Listeners section, add a new listener.

In the SSL Certificate, you will see the one we newly created. Apply the configuration and wait until the environment updates.

Testing time

Yay, we're done. Thanks a lot for bearing with me for so long. If you need any help or have any suggestions, feel free to reach out. Peace!

Avoiding Security Risks must be a part of the development strategy. I mean, I’ve seen a lot of companies first trying to build software, and later after it's ready for UAT, they try to find vulnerabilities and threats by hiring part-time pen testers and security engineers. The developers cannot keep up with fixing bugs, adding features, and doing RND to fix security bugs at that point in time. That would create havoc and be a pain for the organization. Hence, it should be a part of a day to day development life cycle. For example, it can be a part of the CI/CD pipeline.

There are many things that a software developer can do from their end to avoid security risks. A few of them are:

Keep Up With Dependencies

Dependencies are an indispensable part of any system. It is not possible to write everything from scratch and would not be better to re-invent the wheel when there are already a bunch of trusted dependencies/libraries being used by top-notch companies. Always while choosing a dependency/library, a software developer must check the community whether it is supported hitherto, the number of downloads, or companies that use it. In short, a developer must meticulously look into the details. Choosing dependency is one thing but keeping up with it is another. There can be a major bug in the previous versions that you are using and an exploiter can use it to exploit your system. It’s always advisable to check the release notes and keep up to date your dependencies and libraries.

Manage Secrets

We, software developers, and programmers are human beings though we don’t have a life. We, as human beings, find it so hard to manage secrets in our daily life. So is true in software development. There are many secrets that we use like passwords, tokens, keys etcetera. Usually, we, developers have to work under pressure and do everything in a rush. It can abstain us from managing secrets. The examples can be:

• Posting a stack overflow question with code to resolve immediate bug which contains credentials

• Committing and pushing official projects with credentials, keys, tokens in a public Github/Gitlab repo

• Posting things online which contains sensitive information

It must be taken into consideration for maintaining the secrecy and avoiding the apocalypse.

Avoid Sharing Accounts

There is a common trend in a company to share the credentials of an account. Sharing a password is fine until it’s not. The more the credentials of an account are shared with individuals, the more the track of it is lost. Let’s say if the root account of AWS is shared among 20 developers and one of them deleted the EC2 instance then who is responsible for the havoc? How can we know what action is performed by which account because the account is shared?

The account can be created individually, if not possible, team-wise. It will minimize the risk because the account shared by 50 developers if hacked will impact more than the account shared by 4–5 developers. Also, if the account is used by more users, the more vulnerable it is and the tougher it is to manage secrecy.

Manage Permissions

The permissions to the systems, databases, tools, and technologies should be managed properly. It should be only provided to the ones that are accountable. The needed permissions should be granted not more than that. For instance, the client executive should not be provided access to the development environment. The application that needs to upload files to AWS S3 should only be provided access to that operation nothing more than that.

Remember database outrage in Gitlab? One engineer in Gitlab mistakenly deleted the primary production database instead of the secondary which resulted in the loss of 5000 projects, 5000 comments, and 700 new user accounts. One small mistake can result in a loss of reputation and a million dollars. If it can happen to a big company like Gitlab then is it inevitable for you?

Avoid Risky Behaviour

A skilled pilot with decades of experience can crash a plane when things go wrong. Similarly, skilled and trained developers can also create problems when their mental state is not good. Risky behaviors include:

• Setting unrealistic deadlines

• Working through fatigue

• Taking shortcuts and cutting corners

• Rushing through tasks to meet the deadlines and ignoring crucial aspects of the development

A short break or procrastination sometimes can be a good approach to avoiding risks.

Thanks a lot for reading this article. If you have anything in mind, then please feel free to comment or reach out to me. :)

Using shortcuts helps us to do more in less time. I have my favorite IntelliJ IDEA shortcuts mentioned below.

Note: I have GNOME as a keymap setting in my IDE.

Rename (Shift + F6)

This is the most frequently used shortcut for me. It helps to rename the variables or methods names. Let’s see an example.

public List<String> getPaymentList(){
    // logic
return Collections.emptyList();
}

Your senior developer didn’t like the name of your method or let’s say Uncle Bob would hate you for this method name which is why you would like to change it. It had been used in twenty different places and you have to replace the name manually. Can you feel the pain? Go to the method declaration part of your code or to the method calling part, place your cursor to the method name and hit Shift + F6, and rename your method. Voila, you can see the changes being reflected in all the files.

Multi Cursor (Alt + J)

This is personally my favorite shortcut. It is also a shortcut to flex with junior developers. It helps us to multi-select the matching content. Consider the scenario, where you have this SQL file.

INSERT INTO users(id, name, address, phone) VALUES (1, 'John', 'ktm', '122233');
INSERT INTO users(id, name, address, phone) VALUES (2, 'Tim', 'ktm', '122234');
INSERT INTO users(id, name, address, phone) VALUES (3, 'Tom', 'ktm', '122235');
INSERT INTO users(id, name, address, phone) VALUES (4, 'Lindy', 'ktm', '122236');
INSERT INTO users(id, name, address, phone) VALUES (5, 'Catherina', 'ktm', '122237');
INSERT INTO users(id, name, address, phone) VALUES (6, 'Bill', 'ktm', '122238');
// 1000 of lines

You have to add one more column in this SQL called user_type with static value USER, are you going to do it manually? Definitely, not. There might be other options for this use case as well, but I am going to demonstrate the power of Alt + J. In the first line, place your cursor before VALUES and select phone) and hit Alt+J multiple times and you can see the exact word phone) being selected. This is what it looks like:

Move your cursor before ) and type , along with your column name i.e user_type. There you go, we unleashed the power of Alt + J. Also, we can unselect from the last by hitting Alt + Shift + J.

Bookmark (Ctrl+Shift+AnyKey and Ctrl+AnyKey)

If you are working with multiple files, you might have to navigate between methods across different files. It will be a pain to go back and forth. Let’s say you are trying to fix a bug written by somebody else, you are already tired searching codes and you forgot the method name or class name you recently visited, it will be so infuriating. Adding a bookmark will help you to be more productive in such cases.

You can hit Ctrl+Shift+AnyKey to set a bookmark. For eg: Ctrl+Shift+1. Intellij IDEA will show a bookmark icon.

You can work with other files and if you feel like jumping into this code, you can hit Ctrl+AnyKey (Ctrl+1 in this case) and you will be returned to this method. It’s that easy. Similarly, you can remove the bookmark by hitting Ctrl+Shift+AnyKey.

Inline (Ctrl+Alt+N)

I prefer deleting codes to writing codes. I love to refactor the code. This shortcut is used to inline the variable or method call. It’s mostly used while refactoring the code.

Customer customer = getCusomer();
createPaymentIntent(customer);

In the snippet like above, if it makes sense to you to inline getCustomer() method, then you can place your cursor to the customer object and hit Ctrl+Alt+N. It will inline the code and the result, then, looks like:

createPaymentIntent(getCusomer());

Extract Variable/Method/Field/Constant/Parameter

This shortcut also makes refactoring easy.

Snippet-1:

getCustomer(); //returns Customer Object

Select getCustomer() method and hit Ctrl+Alt+V to get the variable returned by the object. The result will be:

Customer customer = getCustomer();

Snippet-2:

Customer customer = new Customer();
customer.setName("Customer");
customer.setAddress("Ktm");
customer.setMobile("9779852365321");

Let’s say, you want to refactor this piece of code into a method. You can select these blocks of codes and enter Ctlr+Alt+M in order to extract to a method. Intellij IDEA will show a popup where you can enter the name of the method along with the visibility (access modifiers).

Likewise, Ctrl+Alt+P is for extracting the method parameter. Ctrl+Alt+C is for extracting a constant variable and Ctrl+Alt+F is for extracting a field variable.

Live Templates

You can save time by using live templates for the code blocks you use repeatedly. Intellij Idea itself provides some live templates. Let's check it out.

• psf: Type psf and hit Tab, public static final snippet will be generated.
• psfs: Type psfs and hit Tab, public static final String snippet will be generated.
• thr: Type thr and hit Tab, throw new snippet will be generated.
• fori: Type fori and hit Tab, a for loop will be generated.
• iter: Type iter and hit Tab, a forEach loop will be generated.

You can also define your custom live templates.

Thanks a lot for reading my article. If you know other cool shortcuts, then feel free to add in the comments :)

There are three ways by which we can initiate a payment using Stripe payment.

1. Stripe Checkout
2. Charges API
3. PaymentIntent API

Stripe Checkout redirects customers to the prebuilt page and accepts payment. This is not what I wanted for my mobile application. Charges API was ok for me but it is recommended for the businesses in the USA and Canada. More importantly, it’s not SCA ready (Strong Customer Authentication) and only works for card payments. The only option left was to use PaymentIntent API.

In this article, I am going to explain the backend and frontend (React-Native tipsi-stripe library) flow for payment using Stripe.

1. The user inputs the card details.
2. The frontend (React-Native) will call the Stripe API to create PaymentMethod object using the card details (Card-number, Expiry date, CVC).
3. The frontend will send the Payment Method Id created from the response of Step-2 along with currency and amount to the backend.
4. The backend will create the Payment Intent Object using the payment method Id.
5. If the status of the PaymentIntent is requires_action, there is secure 3D authentication enabled for the payment and needs further processing. Hence, the backend will send payment intent client_secret to the frontend.
6. The frontend will use this client_secret and proceed for further authentication and payment from the frontend per se.
7. If the status of the PaymentIntent is other than requires_action, the backend will complete the transaction.
8. The backend will receive the subscribed events from the Stripe server using Webhooks. The backend then sends the Push Notification using Expo to the frontend notifying the success and failure of the payment.

Let’s see the code snippets. I used stripe-java library to communicate with the Stripe server.

The dependency in pom.xml looks like:

<dependency>
    <groupId>com.stripe</groupId>
    <artifactId>stripe-java</artifactId>
    <version>${stripe.version}</version>
</dependency>

The createPayment method looks like this:

Stripe.apiKey = this.secretKey;
    PaymentIntentCreateParams params = PaymentIntentCreateParams.builder()
            .setCurrency(currency)
            .setAmount(getConvertedAmount(amount))
            .setPaymentMethod(paymentMethodId)
            .setConfirm(true)              
            .setReceiptEmail(SecurityContext.getUser().getUsername())         
.setConfirmationMethod(PaymentIntentCreateParams.ConfirmationMethod.AUTOMATIC)
.build();

PaymentIntent paymentIntent = createPaymentIntent(params);
if (REQUIRES_ACTION.equals(paymentIntent.getStatus())) {
        //requires 3D secure authentication in frontend
 return paymentIntent.getClientSecret();
    } else {
        return EMPTY;
    }
}

private PaymentIntent createPaymentIntent(PaymentIntentCreateParams params) {
    try {
        return PaymentIntent.create(params);
    } catch (StripeException e) {
        //log
    }
}

The webhooks API will be called by Stripe and it can be configured from the Stripe Dashboard. You can choose the event types that you would like to receive in your webhook endpoint. For payment success and failure, I am listening to payment_intent.succeeded and payment_intent.payment_failed events respectively.

The webhooks API looks like:

@PostMapping(value = "/your-webhook-endpoing")
public ResponseEntity<Void> webhooks(@RequestBody String json, HttpServletRequest httpRequest) {

    Event event = validateStripeHeadersAndReturnEvent(json, httpRequest.getHeader("Stripe-Signature"));
    StripeObject stripeObject = getStripeObject(event);
    PaymentIntent paymentIntent = (PaymentIntent) stripeObject;
    this.stripePaymentService.handlePaymentSuccess(event.getType(), paymentIntent);
    this.stripePaymentService.handlePaymentFailure(event.getType(), paymentIntent);
    return ResponseEntity.status(HttpStatus.OK).build();
}

As you can see, I am getting Stripe-Signature header from the request because I want to validate if the request is being sent by the Stripe server or not. The validateStripeHeadersAndReturnEvent method looks like:

private Event validateStripeHeadersAndReturnEvent(String payload, String headers) {
    try {
        return Webhook._constructEvent_(
                payload, headers, this.webhookSecret
        );
    } catch (JsonSyntaxException e) {
        throw new UnAuthorizedException("Invalid payload");
    } catch (SignatureVerificationException e) {
        throw new UnAuthorizedException("Invalid Signature");
    }
}

You can write your own logic after you receive webhooks. I am sending the success and failure push notifications.

Thanks a lot for reading this article :)

I have latitude and longitude stored in the table. The Entity Store looks like:

@Entity
@Table(name = "STORE")
@Getter
@Setter
public class Store {
    @Id
    @GeneratedValue(strategy = GenerationType._IDENTITY_)
    private long id;
    private double latitude;
    private double longitude;
}

Let’s say now we want to find all the stores within a 10-kilometer distance from our current location then using Spring Data JPA repository we can do it as:

public interface StoreRepository extends JpaRepository<Store, Long>{

String HAVERSINE_FORMULA = "(6371 * acos(cos(radians(:latitude)) * cos(radians(s.latitude)) *" +
        " cos(radians(s.longitude) - radians(:longitude)) + sin(radians(:latitude)) * sin(radians(s.latitude))))";

@Query("SELECT s FROM Store s WHERE " + HAVERSINE_FORMULA + " < :distance ORDER BY "+ HAVERSINE_FORMULA + " DESC")
List<Store> findStoresWithInDistance(
@Param("latitude") double latitude,
 @Param("longitude") double longitude,
 @Param("distance") double distanceWithInKM );

The parameters latitude and longitude are your current location values whereas distance represents the distance you want to search within. (10KM in our case).

As you can see, in the Haversine Formula, we have used 6371. This is the value for the radius of the earth in KM. If you want to search using miles then you need to change it to 3961 from 6371.

Thanks a lot for reading my article :)

Design principles are basic guidelines that help us to avoid bad object-oriented design. Nobody is going to point a gun towards you and make you adhere to it strictly. It’s not a rule of thumb but it will definitely help you. We are now going to see three principles.

1. Encapsulate what varies.
2. Favor composition over inheritance.
3. Program to interface.

Encapsulate what varies.

The principle is so simple. Identify the aspects of the code that varies and isolate it with what stays the same. You gotta ask yourself

“Does this code change every time I get the new requirement?”

If the answer is yes then you now know what to do. Encapsulate. Let’s see an example.

public void connectToDatabase(String connectionType) {
    DBConnection connection = null;
    if ("mysql".equals(connectionType)) {
        connection = new MySqlConnection();
    } else if("mongodb".equals(connectionType)){
        connection = new MongoConnection();
    }else if("postgres".equals(connectionType)){
        connection = new PostgresConnection();
    }
    connection.createConnection();
}

I bet every one of us has seen code like this and who knows we may still have such code running in production. So, let’s say we need to add an Oracle database in our code. How are we going to add it? Another else if condition, isn’t it? But let’s say there are a bunch of other important codes in the same file and while adding a new Oracle database you mistakenly touched other production codes in the same file which introduced many newer bugs. Had it been encapsulated, then there would have been a single place to change. By encapsulating it, our design will be much more flexible.

The part that will change with every new requirement is if-else conditions. So, we can create a factory class that will be solely responsible for creating database connections. I will not show how to create a factory class but I will show how the code looks once we encapsulated all the logics inside the factory class.

public void connectToDatabase(String connectionType) {
    DBConnectionFactory dbConnectionFactory = new DBConnectionFactory();
    DBConnection connection = dbConnectionFactory.getConnection(connectionType);
    connection.createConnection();
}

With this approach, let’s say if you want to add an H2 database connection then you have to change only in DBConnectionFactory class.

Favor composition over inheritance

In object-oriented programming (OOP), inheritance is IS-A relationship (A car is a vehicle) whereas composition is HAS-A relationship (A car has an engine).

Inheritance provides a great way to reuse the code but it becomes less effective once the hierarchy grows on. Classes and objects created through inheritance are tightly coupled) because if something is changed in the base class then it will affect its subclasses. But it’s not true for composition. The classes and objects created through composition are loosely coupled). There is another great benefit of using Composition over Inheritance. Inheritance is not easily testable because to test derived class you also need superclass but the composition is as we can use mock objects.

Program to interface

The term interface here doesn’t merely mean the keyword we have in Java programming language. It is a kind of contract that has a bunch of rules that needs to be followed by concrete classes that implement it. It is often called as program to the supertype. If we program to an interface rather than the concrete implementations then it provides the flexibility to exploit polymorphism.

The interface provides rules and doesn’t care whoever implements it and how the implementation looks like. Let’s take a real-world simple example.

interface FileUpload {
    void upload(Object o);
}

We want to upload the file in our application. There may be many different ways to do so. We can use Cloudinary, AWS S3 bucket, upload care, etc. So the implementations of FileUpload would look like AmazonS3FileUpload, CloudinaryFileUpload, UploadCareFileUpload etcetera.

Let’s program to interface.

FileUpload fileUpload = new CloudinaryFileUpload();
// code related to fileupload

Great, our file uploading feature is working correctly and after one year, we want to switch our file uploading from Cloudinary to AmazonS3. We just need to change the implementation like:

FileUpload fileUpload = new AmazonS3FileUpload();

It will not break other codes because we are relying on the interface and the methods provided by it. We can only use methods defined within the FileUpload interface. Had it been concrete implementation with a bunch of extra methods, then it would have created a havoc.

//program to concrete implementation
CloudinaryFileUpload fileUpload = new CloudinaryFileUpload();
//code related to fileUpload

So, it’s always a good idea to program to an interface. Besides, the flexibility it provides, it is also easy to test. We can easily mock FileUpload interface wherever necessary.

Thanks a lot for reading my article. If you have any suggestions, then they are welcomed.