Follow these simple steps with examples to create an SSL/TLS certificate with AWS Certificate Manager (ACM)

Implementing SSL/TLS certificates is a crucial aspect of web security. These certificates establish encrypted connections between clients and servers, protecting sensitive information from unauthorized access.If security is not your concern. Did you know that SSL/TLS can help improve your website's search ranking? Search engines use SSL/TLS as a factor in their algorithms when determining which websites to display in search results.AWS Certificate Manager (ACM) is an AWS managed service that simplifies the process of provisioning, managing, and deploying SSL/TLS certificates. ACM handles certificate generation, renewal, revocation, and integration with various AWS services, and best of all. It's free.ACM and other certificate authorities like Let's Encrypt have made it incredibly easy to generate and use SSL/TLS certificates. Therefore, there's no excuse for not securing your website traffic.<h2 id="create-certificate">Create Certificate</h2>To create the certificate, follow these steps:<ol><li>Navigate to the AWS Certificate Manager (ACM) in the AWS Management Console.</li><li>Click on "Request a certificate", click "Next", and enter the domain name(s) for which you want to create the certificate. You can specify multiple domain names or use wildcard certificates.Wildcard certificates start with an asterisk (*), e.g., *.yourdomain.com. The advantage of wildcard certificates is that they will match any first-level subdomain, e.g., www.yourdomain.com, but it comes with some security concerns.</li><li>Choose the validation method.<ul><li>DNS: This method requires adding CNAME record(s) to your domain's DNS configuration.</li><li>Email: ACM sends validation emails to the email addresses associated with your domain(s).</li></ul>In this guide, we'll use the DNS validation method, which is also recommended by ACM.</li><li>For the Key algorithm, use the default "RSA 2048".</li></ol><img class="image" src="https://thedevops.world/content/images/u-Fch0PCZbKr55qyMVySq.gif" alt="Create SSL/TLS certificate AWS Certificate Manager"><h2 id="certificate-validation">Certificate Validation</h2><h3>Amazon Route 53</h3>If you use Amazon Route 53 to manage your DNS records, you can update your records through ACM directly.<ol><li>Go to the certificate that you just created.</li><li>Under "Domains", click on "Create records in Route 53".</li><li>Select the Domain for which the certificate was created.</li><li>Click on "Create records".</li><li>Wait for the status to change from "Pending validation" to "Issued". This may take a few minutes to complete.</li></ol><img class="image" src="https://thedevops.world/content/images/6usUhNmf79fI7BLUuC7z1.gif" alt="AWS Certificate Manager validation"><h3>Other DNS service providers</h3>If your domain DNS service is managed by a domain registrar like GoDaddy, Namecheap, etc. You'll have to create the CNAME record(s) yourself.Or if you want to use the method above for validation. You can move your domain DNS service to Amazon Route 53. To do so, follow these <a target="_blank" rel="noopener noreferrer nofollow" href="/5-steps-move-dns-service-from-godaddy-to-aws-route-53-rB6EV">5 Steps: Migrate DNS Service From GoDaddy To AWS Route 53</a>. The article uses GoDaddy as an example, but the process is similar for most DNS providers out there.To validate the certificate. Follow these steps:<ol><li>Go to the certificate that you just created.</li><li>Under "Domains", copy the values of the "CNAME name" and "CNAME value".</li><li>Go to your DNS service provider.</li><li>Create CNAME record(s) with the values from the 2nd step.Depending on the provider, you will most likely need to remove the last dot from the copied values and the domain part from the "CNAME name".</li><li>Back into the ACM Console. Wait for the certificate status to change from "Pending validation" to "Issued". This may take a few minutes to complete.</li></ol><h2 id="conclusion">Conclusion</h2>That's it! If you followed the steps in this guide, you now have a valid certificate for use with Amazon CloudFront, Elastic Load Balancing (ELB), Amazon API Gateway, and AWS Elastic Beanstalk.

How to: Create SSL/TLS Certificate on AWS

Explore practical applications of Type Guards. Learn how to enhance code precision and reliability with examples ranging from data validation to API responses.

In the world of TypeScript, precision and reliability are paramount. This is where Type Guards step onto the stage. Beyond theoretical discussions, this article ventures into practical terrain, demonstrating the tangible impact of Type Guards in real-world scenarios. Through carefully chosen examples, we'll explore how these constructs fortify your code against unexpected behavior. For those interested in a deeper theoretical exploration, our previous article - <a href="https://thedevops.world/demystifying-user-defined-type-guards-in-typescript-t-AiV">Demystifying User-Defined Type Guards in TypeScript</a> - provides an insightful foundation.<h2 id="scenario-1:-ensuring-data-integrity-validating-input-types-from-external-sources"> Scenario 1: Ensuring Data Integrity - Validating Input Types from External Sources</h2>In practical coding scenarios, we often encounter situations where data from external sources, like APIs, may not align perfectly with our expectations. One such case arises when handling vehicle data, where we receive a string claiming to represent a vehicle type. How can we be certain that it's a valid input?Here's a code snippet illustrating this scenario:<pre><code class="language-typescript">const VehicleTypeValues = ['car', 'motorbike', 'trailer', 'caravan', 'transporter', 'truck'] as const;
type VehicleType = typeof VehicleTypeValues[number];

const isSupportedVehicleType = (input?: string): input is VehicleType =&gt; 
 VehicleTypeValues.some((value) =&gt; value === input);

// Usage Example:
const apiResponse: string | undefined = 'car';

if (isSupportedVehicleType(apiResponse)) {
 // apiResponse is now of type VehicleType
 console.log(`The received vehicle type "${apiResponse}" is valid.`);
} else {
 console.log(`The received vehicle type "${apiResponse}" is not supported.`);
}</code></pre>We first define a set of supported vehicle types using a constant array. Then, we create a type guard function, <code>isSupportedVehicleType</code>, which takes an optional string input and returns a boolean indicating whether the input is a valid vehicle type. This function employs <code>VehicleTypeValues.some</code> to check if the input matches any of the supported vehicle types. If a match is found, it returns true, indicating that the input is indeed a valid vehicle type. From this point on, you are safe to assume that <code>input</code> is of type <code>VehicleType</code>.<h2 id="scenario-2:-validating-paths-confirming-string-integrity-with-json-keys"> Scenario 2: Validating Paths - Confirming String Integrity with JSON Keys</h2>In web development, it's often crucial to verify that a given string corresponds to a key within a JSON object. This scenario arises when dealing with dynamic page paths in web applications.<pre><code class="language-typescript">type Page = {
 url: string;
 content: string;
 isActive: boolean;
};

type Pages = {
 [path: string]: Page;
};

const isValidPath = (path: string): path is keyof typeof jsonData =&gt; {
 return path in jsonData;
};

// Usage Example:
const jsonData: Pages = {
 '/article1': {
 url: '/article1',
 content: 'This is the content of article 1',
 isActive: true,
 },
 '/article2': {
 url: '/article2',
 content: 'This is the content of article 2',
 isActive: true,
 },
 '/about': {
 url: '/about',
 content: 'This is the about page',
 isActive: true,
 },
};

const userInput1 = '/article1';
const userInput2 = '/abc';

console.log(isValidPath(userInput1)); // Output: true
console.log(isValidPath(userInput2)); // Output: false</code></pre>The provided code snippet showcases an example where we're managing a collection of pages represented by the <code>Page</code> type. These pages are stored in an object called <code>jsonData</code>, with each page identified by a unique path. The <code>isValidPath</code> function acts as a type guard, ensuring that a given input <code>path</code> is a valid key within <code>jsonData</code>. In the usage example, we test two inputs: <code>userInput1</code> with the path <code>'/article1'</code> (which exists in <code>jsonData</code>) and <code>userInput2</code> with the path <code>'/abc'</code> (which does not exist). The function correctly identifies the validity of these paths, providing reliable type narrowing.<h2 id="scenario-3:-user-authentication-management-distinguishing-authenticated-and-guest-users"> Scenario 3: User Authentication Management - Distinguishing Authenticated and Guest Users</h2>In most applications, managing user authentication is a fundamental aspect. This scenario tackles the challenge of distinguishing between authenticated users and guests using type guards.<pre><code class="language-typescript">interface AuthenticatedUser {
 username: string;
 token: string;
}

interface GuestUser {
 isGuest: true;
}

type User = AuthenticatedUser | GuestUser;

function isAuthenticatedUser(user: User): user is AuthenticatedUser {
 return 'token' in user;
}

// Usage Example:
const authenticatedUser: AuthenticatedUser = {
 username: 'john_doe',
 token: 'xyz123',
};

const guestUser: GuestUser = {
 isGuest: true,
};

console.log(isAuthenticatedUser(authenticatedUser)); // Output: true
console.log(isAuthenticatedUser(guestUser)); // Output: false</code></pre>In this code snippet, we define two interfaces, <code>AuthenticatedUser</code> and <code>GuestUser</code>, representing authenticated and guest users respectively. The <code>User</code> type is a union of both interfaces. The <code>isAuthenticatedUser</code> function acts as a type guard, verifying whether a given user is authenticated. It is a type predicate function that checks if the provided <code>user</code> object contains the property <code>token</code>. If it does, TypeScript will narrow down the type to <code>AuthenticatedUser</code>.<h2 id="scenario-4:-navigating-api-responses-distinguishing-success-from-errors"> Scenario 4: Navigating API Responses - Distinguishing Success from Errors</h2>Managing API responses, especially those that may include error payloads, is a common challenge. This scenario demonstrates how type guards can be a powerful tool to discern between successful and error responses.<pre><code class="language-typescript">interface ApiResponse&lt;T&gt; {
 success: boolean;
 data?: T;
 error?: string;
}

function handleApiResponse&lt;T&gt;(response: ApiResponse&lt;T&gt;) {
 if (response.success) {
 // Handle successful response
 console.log('Success! Data:', response.data);
 } else if (response.error) {
 // Handle error response
 console.error('Error:', response.error);
 }
}

// Usage Example:
const successResponse: ApiResponse&lt;number&gt; = {
 success: true,
 data: 42,
};

const errorResponse: ApiResponse&lt;number&gt; = {
 success: false,
 error: 'Internal Server Error',
};

handleApiResponse(successResponse); // Output: Success! Data: 42
handleApiResponse(errorResponse); // Output: Error: Internal Server Error</code></pre>In this code snippet, we start by defining an <code>ApiResponse&lt;T&gt;</code> interface, which can represent either successful or error responses. The <code>handleApiResponse</code> function, which takes an <code>ApiResponse&lt;T&gt;</code> as an argument, employs a type guard to differentiate between the two types of responses. If <code>response.success</code> is true, it's treated as a successful response, and the data is logged to the console. On the other hand, if <code>response.error</code> exists, indicating an error response, the error message is logged. This code structure allows for effective management of API responses, enhancing code reliability in real-world scenarios.<h2 id="embrace-type-guards:-elevate-your-code's-precision-and-reliability"> Embrace Type Guards: Elevate Your Code's Precision and Reliability</h2>We've just scratched the surface of what type guards can actually do. Now it's your time to shine! Incorporate these techniques into your projects and make your code run with precision and reliability. Say goodbye to unexpected surprises and hello to a more confident and efficient development journey.

Real-World Applications of Type Guards in TypeScript

Master TypeScript's user-defined type guards, ensuring precise typing and error-free code. Learn with real-world examples!

You know you're in the big leagues of TypeScript when you start talking about user-defined type guards. It's like the VIP section of type safety, where you get to be the bouncer deciding who gets in and who doesn't. In this wild world of TypeScript, user-defined type guards are your secret weapon. They're like the precision-guided missiles of typing, ensuring that your variables are exactly what you expect them to be. So, grab your virtual bouncer suit, because we're about to dive into the fancy world of user-defined type guards! <h2 id="purpose-of-user-defined-type-guards">Purpose of User-Defined Type Guards</h2>In the world of TypeScript, user-defined type guards are like the vigilant gatekeepers of a grand event. Their main goal is to ensure that only the right types gain entry. They're the discerning judges, meticulously examining variables to confirm their true identity. By implementing these custom guards, you're essentially setting up a strict guest list for your code. This tailored approach to typing is your key to elevating the overall security and reliability of your TypeScript projects. This article delves into concrete examples where user-defined type guards shine. Through cases like validating inputs and managing dynamic data, we see their crucial role in maintaining type integrity.<h2 id="type-predicate-functions:-the-art-of-defining-types">Type Predicate Functions: The Art of Defining Types</h2>Crafting robust type definitions is an art, and Type Predicate Functions are the master strokes that lend impeccable definition to your code. These functions act as keen evaluators, accurately inspecting variables for their true nature. This section shows how leveraging Type Predicate Functions elevates the overall quality and dependability of your TypeScript projects.<h3>Example 1: Filtering VIP Cats</h3>Consider a scenario where you have an array of different types of cats, each with its own set of attributes. You want to filter out only the "fancy" cats based on specific criteria.<pre><code class="language-typescript">interface Cat {
 name: string;
 breed: string;
 accessories?: string[];
}

interface FancyCat extends Cat {
 accessories: string[];
}

function isFancyCat(cat: Cat): cat is FancyCat {
 return !!cat.accessories &amp;&amp; cat.accessories.length &gt; 0;
}

const cats: Cat[] = [
 { name: 'Whiskers', breed: 'Siamese', accessories: ['Bow Tie', 'Top Hat'] },
 { name: 'Fluffy', breed: 'Persian' },
 { name: 'Mittens', breed: 'Tabby', accessories: ['Diamond Collar'] }
];

const fancyCats = cats.filter(isFancyCat);</code></pre>Here, the <code>isFancyCat</code> function serves as the bouncer, allowing only the "fancy" cats with accessories to enter the VIP lounge. On a more serious note, we've explored the use of user-defined type guards to distinguish between regular cats and their more sophisticated counterparts, the FancyCats. By employing the <code>isFancyCat</code> function, we've effectively narrowed down the types based on the presence of accessories, enhancing our code's precision.This technique proves invaluable when dealing with complex data structures, where different objects may have distinct properties. With user-defined type guards, we can confidently and accurately categorise these objects, ensuring that our code operates with maximum clarity and reliability.<h3>Example 2: Handling Specialised Data Structures</h3>Suppose you're working with a specialised data structure that can have varying shapes based on certain conditions. You want to ensure that the structure adheres to the expected shape before processing it.<pre><code class="language-typescript">type DataStructureA = { kind: 'A'; value: number };
type DataStructureB = { kind: 'B'; message: string };
type DataStructure = DataStructureA | DataStructureB;

function isDataStructureA(data: DataStructure): data is DataStructureA {
 return data.kind === 'A';
}

function processData(data: DataStructure) {
 if (isDataStructureA(data)) {
 // Process data as type A
 console.log(`Processing data of kind A with value: ${data.value}`);
 } else {
 // Process data as type B
 console.log(`Processing data of kind B with message: ${data.message}`);
 }
}

const dataA: DataStructure = { kind: 'A', value: 42 };
const dataB: DataStructure = { kind: 'B', message: 'Hello World' };

processData(dataA);
processData(dataB);</code></pre>In this case, we have a <code>DataStructure</code> type that can take two different shapes: one with a <code>kind</code> of 'A' and a <code>value</code> of number, and another with a <code>kind</code> of 'B' and a <code>message</code> of string.The <code>isDataStructureA</code> function acts as our type guard, allowing us to discern whether a given <code>DataStructure</code> object is of type 'A' or 'B'. This ensures that we can confidently apply specialised logic to each type without encountering type errors.<h3>Example 3: Validating User Inputs</h3>Imagine you're building a form validation system where different input types have varying validation criteria. You want to ensure that each input type is validated correctly before submission.<pre><code class="language-typescript">interface TextInput {
 type: 'text';
 value: string;
}

interface NumberInput {
 type: 'number';
 value: number;
}

type Input = TextInput | NumberInput;

function isValidTextInput(input: Input): input is TextInput {
 return input.type === 'text' &amp;&amp; input.value.length &gt; 0;
}

function isValidNumberInput(input: Input): input is NumberInput {
 return input.type === 'number' &amp;&amp; !isNaN(input.value);
}

function validateInput(input: Input) {
 if (isValidTextInput(input)) {
 console.log(`Valid text input: ${input.value}`);
 } else if (isValidNumberInput(input)) {
 console.log(`Valid number input: ${input.value}`);
 } else {
 console.log('Invalid input');
 }
}

const textInput: Input = { type: 'text', value: 'Hello' };
const numberInput: Input = { type: 'number', value: 42 };

validateInput(textInput);
validateInput(numberInput);</code></pre>In this scenario, we have two types of inputs: <code>TextInput</code> and <code>NumberInput</code>. Each type has its own specific validation criteria.The functions <code>isValidTextInput</code> and <code>isValidNumberInput</code> act as type guards, allowing us to determine whether a given input is of type <code>TextInput</code> or <code>NumberInput</code>. This enables us to apply the appropriate validation logic based on the type of input provided.By utilising user-defined type guards, we ensure that each input type is validated correctly before further processing. This approach enhances the reliability and accuracy of our form validation system, particularly in situations where different input types have distinct validation requirements.<h2 id="assertion-functions:-asserting-types-with-authority">Assertion Functions: Asserting Types with Authority</h2>TypeScript's Assertion Functions are a force to be reckoned with when it comes to type validation. In contrast to Type Predicate Functions, which verify types based on conditions, Assertion Functions assert that a variable unequivocally belongs to a particular type. They offer a level of confidence that goes beyond mere checks. This segment delves into the strengths of Assertion Functions and provides insights into how they differ from Type Predicate Functions, adding an extra layer of certainty to your typing toolkit.<h3>Example 1: Asserting Fancy Cats</h3>Let's slightly modify the Fancy Cats example from the Type Predicate Functions section to work with Assertion Functions instead.<pre><code class="language-typescript">interface Cat {
 name: string;
 breed: string;
 accessories?: string[];
}

interface FancyCat extends Cat {
 accessories: string[];
}

function assertFancyCat(cat: Cat): asserts cat is FancyCat {
 if (!('accessories' in cat)) {
 throw new Error(`This cat is not fancy enough to enter the VIP lounge.`);
 }
}

const myCat: Cat = { name: 'Whiskers', breed: 'Siamese', accessories: ['Bow Tie', 'Top Hat'] };
assertFancyCat(myCat);

// Now myCat is treated as FancyCat
const fancyAccessories = myCat.accessories;</code></pre>Unlike Type Predicate Functions, which narrow down types based on conditions, the <code>assertFancyCat</code> function takes a more assertive stance. It boldly declares that a given cat is of type <code>FancyCat</code> by ensuring the presence of accessories. This approach provides an extra layer of certainty in typing, going beyond mere checks to enforce precise type expectations. If a cat doesn't meet the criteria, an error is thrown, reflecting the strict assertion nature of this function.<h3>Example 2: Asserting Specialised Data Structures</h3>This is the same example from the Type Predicate Functions section modified in a way to better showcase how assertion functions work.<pre><code class="language-typescript">type DataStructureA = { kind: 'A'; value: number };
type DataStructureB = { kind: 'B'; message: string };
type DataStructure = DataStructureA | DataStructureB;

function assertDataStructureA(data: DataStructure): asserts data is DataStructureA {
 if (data.kind !== 'A') {
 throw new Error(`This data structure is not of kind 'A'.`);
 }
}

const myData: DataStructure = { kind: 'A', value: 42 };
assertDataStructureA(myData);

// Now myData is treated as { kind: 'A', value: number }
const processedValue = myData.value;</code></pre>Here, Assertion Functions take center stage in ensuring the correct categorisation of data structures. The <code>assertDataStructureA</code> function goes beyond traditional checks by explicitly asserting that the provided data structure is of kind 'A'. This approach differs from Type Predicate Functions, which focus on narrowing down types based on conditions. With Assertion Functions, we're not merely verifying; we're asserting a specific type, providing a higher level of confidence in our type declarations.<h3>Example 3: Asserting Valid Inputs</h3>Similarly as above, this is also an equivalent of the Type Predicate Functions example modified to work with assertion functions.<pre><code class="language-typescript">interface TextInput {
 type: 'text';
 value: string;
}

interface NumberInput {
 type: 'number';
 value: number;
}

type UserInput = TextInput | NumberInput;

function assertValidTextInput(input: UserInput): asserts input is TextInput {
 if (input.type !== 'text' || typeof input.value !== 'string') {
 throw new Error(`Invalid text input.`);
 }
}

const userInput: UserInput = { type: 'text', value: 'Hello' };
assertValidTextInput(userInput);

// Now userInput is treated as TextInput
const stringValue = userInput.value;</code></pre>In this example, we showcase how Assertion Functions excel in validating user inputs. The <code>assertValidTextInput</code> function asserts that a given input is of type 'text', offering a level of certainty that surpasses the traditional checks performed by Type Predicate Functions. This approach ensures that we're working with valid text inputs, leaving no room for ambiguity. If the input doesn't meet the specified criteria, an error is thrown, underscoring the assertive nature of this type guard.<h2 id="combining-both-techniques">Combining Both Techniques</h2><pre><code class="language-typescript">interface Animal {
 type: string;
 name: string;
 wingspan?: number;
 swimDepth?: number;
}

interface Bird extends Animal {
 type: 'bird';
 wingspan: number;
}

interface Fish extends Animal {
 type: 'fish';
 swimDepth: number;
}

function isBird(animal: Animal): animal is Bird {
 return animal.type === 'bird';
}

function isFish(animal: Animal): animal is Fish {
 return animal.type === 'fish';
}

function assertBirdWithLargeWingspan(animal: Animal): asserts animal is Bird {
 if (isBird(animal) &amp;&amp; animal.wingspan &gt; 2) {
 return;
 }
 throw new Error(`This is not a bird with a large wingspan.`);
}

const zoo: Animal[] = [
 { type: 'animal', name: 'Lion' },
 { type: 'bird', name: 'Eagle', wingspan: 2.5 },
 { type: 'bird', name: 'Sparrow', wingspan: 0.2 },
 { type: 'fish', name: 'Trout', swimDepth: 10 },
 { type: 'fish', name: 'Goldfish', swimDepth: 1 },
];

const birds: Bird[] = zoo.filter(isBird);
birds.forEach(assertBirdWithLargeWingspan);

const largeWingspanBirdNames: string[] = birds.map((bird) =&gt; bird.name);</code></pre>In this example, we have a zoo with various animals, some of which are birds and fish. We use both Type Predicates (<code>isBird</code> and <code>isFish</code>) and an Assertion Function (<code>assertBirdWithLargeWingspan</code>) to perform advanced type narrowing.First, we filter the animals to get an array of only birds using <code>isBird</code>. Then, we iterate through the birds and use <code>assertBirdWithLargeWingspan</code> to assert that each bird has a wingspan greater than 2 units. If the assertion fails, an error is thrown.Finally, we extract the names of birds with large wingspans. This example showcases how Type Predicates and Assertion Functions can be combined to perform complex type narrowing and validation in TypeScript, ensuring precise typing and robust error handling.<h2 id="pitfalls-to-watch-out-for">Pitfalls to Watch Out For</h2>Creating user-defined type guards can be a powerful tool, but it's not without its potential pitfalls. One such pitfall is overly complex type guard logic, which can make the code hard to understand and maintain. Another common mistake is forgetting to include the <code>is</code> keyword in the return type of the type guard function. Yet another mistake is forgetting to return a boolean value in the type guard function. These simple omissions can lead to unexpected type narrowing. To sidestep these issues, keep your type guards clear and concise, and always double-check your return types.<h2 id="conclusion...use-type-guards-because-safety-is-the-coolest-accessory!">Conclusion...use type guards because safety is the coolest accessory!</h2>So there you have it! User-defined type guards are like the vigilant gatekeepers of the TypeScript world, ensuring that only the right guests enter the VIP lounge. They're not just fancy jargon; they're your ticket to a safer, more robust codebase.Remember, these guards are your trusty sidekicks in the quest for type safety. But like any good sidekick, they have their quirks. Watch out for common pitfalls, like forgetting that all-important boolean return, and steer clear of overly complex logic.With user-defined type guards in your toolkit, you'll be navigating the TypeScript realm with confidence, knowing that your types are in good hands. So go ahead, let those guards do their thing, and code on with style and safety!

Demystifying User-Defined Type Guards in TypeScript

5 Steps: Migrate DNS Service From GoDaddy To AWS Route 53

Migrate your DNS service from GoDaddy to AWS Route 53 in five simple steps

Migrating your DNS service from GoDaddy to AWS Route 53 is relatively straightforward. Here is a simple guide with step-by-step instructions to help you through the process:<ul><li><a href="#step-1:-create-hosted-zone">Step #1: Create Hosted Zone</a></li><li><a href="#step-2:-import-dns-records">Step #2: Import DNS Records</a></li><li><a href="#step-3:-get-hosted-zone-nameservers">Step #3: Get Hosted Zone Nameservers</a></li><li><a href="#step-4:-update-nameservers-on-godaddy">Step #4: Update Nameservers on GoDaddy</a></li><li><a href="#step-5:-wait-for-dns-propagation">Step #5: Wait for DNS Propagation</a></li><li><a href="#bonus:-provision-route-53-hosted-zone-and-records-with-terraform">Bonus: Provision Route 53 Hosted Zone and Records with Terraform</a></li></ul><h2 id="step-1:-create-hosted-zone">Step #1: Create Hosted Zone</h2>The first step is to create a new Route 53 Hosted Zone. To do this, log into your account, navigate to the Route 53 dashboard, look for the "Create hosted zone" button, and click on it. Enter your domain name, select the "Public hosted zone" option, and click the "Create hosted zone" button to complete the process.<img class="image" src="https://thedevops.world/content/images/j2DfF-t07k6HaOSjrXfyS.jpeg" alt="Route 53 create hosted zone"><h2 id="step-2:-import-dns-records">Step #2: Import DNS Records</h2>Before going further, you should import your existing DNS records (A, CNAME, MX, TXT, etc.) from GoDaddy. Within the Hosted Zone you created, click on the "Create record" button. Enter the relevant details for your DNS record(s) and click the "Create records" button to save your changes.<img class="image" src="https://thedevops.world/content/images/S4QAtjCypa_ugLXyGQfbF.jpeg" alt="Create Route 53 record">If you have a large number of records. You can export the existing records from GoDaddy and import them into Route 53. To do so, log in to your GoDaddy account, find and click on "My Account", then click on the "Domains" section. From here, click on the domain you want to export the records, then click on the "DNS" tab. Within the "DNS Records" view, click on the "... Actions" button and then on the "Export Zone File". This action will download a file with the records on your machine. Open the file and copy the contents of it.<img class="image" src="https://thedevops.world/content/images/0EzczxD7L87PUbqlgh8oI.jpeg" alt="Export Zone File GoDaddy">In the Route 53 dashboard, click on the Hosted Zone you created earlier and click the "Import zone file" button. Within the Import zone file view, paste the contents of the file you copied previously. When done, click the "Import" button to save your records.<img class="image" src="https://thedevops.world/content/images/4PNacOfg51K3-cPptLPXV.jpeg" alt="Route 53 import zone file"><h2 id="step-3:-get-hosted-zone-nameservers">Step #3: Get Hosted Zone Nameservers</h2>Within the Hosted Zone you created, look for, and copy the nameservers listed under the "NS" record. You will need them in the next step.<img class="image" src="https://thedevops.world/content/images/MgWBBi381jRvZpTMK6Uyy.jpeg" alt="Route 53 NS Record"><h2 id="step-4:-update-nameservers-on-godaddy">Step #4: Update Nameservers on GoDaddy</h2>In your GoDaddy account, click on "My Account" and then on the "Domains" section. Click on the domain you want to update, then click on the "DNS" tab. Find the "Nameservers" section and click on "Change Nameservers". Select "I'll use my own nameservers" and enter the Route 53 nameservers you copied earlier. Click on the "Save" button to save your changes.<img class="image" src="https://thedevops.world/content/images/-xyvbC61UwyuuojRbdM0J.jpeg" alt="Change Nameservers GoDaddy"><h2 id="step-5:-wait-for-dns-propagation">Step #5: Wait for DNS Propagation</h2>DNS propagation can take up to 48 hours to complete. Please be patient and wait for the DNS propagation to complete before making further changes. In the meantime, you can read this <a target="_blank" rel="noopener noreferrer nofollow" href="https://ns1.com/resources/dns-propagation">article</a> to learn more.That's all! You moved your DNS service from GoDaddy to AWS Route 53. From now on, all your DNS records and configurations will be handled through Route 53.<h2 id="bonus:-provision-route-53-hosted-zone-and-records-with-terraform">Bonus: Provision Route 53 Hosted Zone and Records with Terraform</h2>If you want to set up the Route 53 Hosted Zone and Records as infrastructure as code (IaC), you can use the following terraform configuration example.<pre><code class="language-ini">resource "aws_route53_zone" "example_zone" {
 name = "yourdomain.com"
}

resource "aws_route53_record" "example_record" {
 zone_id = aws_route53_zone.example_zone.zone_id
 name = "yourdomain.com"
 type = "A"
 ttl = 60
 records = [
 # "your server IP"
 ]
}

resource "aws_route53_record" "www_example_record" {
 zone_id = aws_route53_zone.example_zone.zone_id
 name = "www.yourdomain.com"
 # ...
}

output "example_zone_nameservers" {
 value = aws_route53_zone.example_zone.name_servers
 description = "The nameservers of example_zone hosted zone"
}</code></pre>

5 Steps: Move DNS Service From GoDaddy To AWS Route 53

A step-by-step guide on how to automate and deploy a web application on AWS with Terraform and GitHub Actions.

Guide to Deploy a Web App on AWS with Terraform and GitHub Actions

The Top 10 Kubectl Commands Every DevOps Engineer Needs to Know

These are the top 10 kubectl commands you’ll find yourself often using if you are a DevOps engineer or anyone working with Kubernetes.

If you are a new or experienced DevOps engineer and just got into the Kubernetes universe, here are the top 10 kubectl commands you’ll use most often and have to get familiar with.<ol><li><code>kubectl get</code>&nbsp;- This command allows you to retrieve information about the objects in your Kubernetes cluster. For example, you can use&nbsp;<code>kubectl get pods</code>&nbsp;to get a list of all the pods in your cluster, or&nbsp;<code>kubectl get deployments</code> to get a list of all the deployments.Example output:<pre><code class="language-shell">$ kubectl get pods
NAME READY STATUS RESTARTS AGE
my-app-7c5f9fd5b8-2lkf7 1/1 Running 0 22m
my-app-7c5f9fd5b8-d8vbt 1/1 Running 0 22m</code></pre></li><li><code>kubectl describe</code>&nbsp;- This command allows you to get detailed information about a specific object in your Kubernetes cluster. For example, you can use&nbsp;<code>kubectl describe pod &lt;pod-name&gt;</code>&nbsp;to get detailed information about a specific pod, including its status, IP address, and the containers it is running.Example output:<pre><code class="language-shell">$ kubectl describe pod my-app-7c5f9fd5b8-2lkf7
Name: my-app-7c5f9fd5b8-2lkf7
Namespace: default
Priority: 0
Node: k8s-worker-1/10.240.0.5
Start Time: Sun, 15 Sep 2019 18:42:23 +0000
Labels: app=my-app
 pod-template-hash=7c5f9fd5b8
Annotations: &lt;none&gt;
Status: Running
IP: 10.244.2.3
Containers:
 my-app:
 Container ID: docker://827983f47f9ce9a7b3bbf3a7d3aee081c72fa8f2dcc69f7b6a9b9f9d03ec8c6d
 Image: my-app:1.0.0
 Image ID: docker-pullable://my-app@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf
 Port: &lt;none&gt;
 Host Port: &lt;none&gt;
 State: Running
 Started: Sun, 15 Sep 2019 18:42:24 +0000
 Ready: True
 Restart Count: 0
 Environment: &lt;none&gt;
 Mounts:
 /var/run/secrets/kubernetes.io/serviceaccount from default-token-zfqc5 (ro)
Conditions:
...</code></pre></li><li><code>kubectl create</code>&nbsp;- This command allows you to create new objects in your Kubernetes cluster. For example, you can use&nbsp;<code>kubectl create deployment &lt;deployment-name&gt; --image=&lt;image-name&gt;</code>&nbsp;to create a new deployment that runs the specified Docker image.Example output:<pre><code class="language-shell">$ kubectl create deployment my-app --image=my-app:1.0.0
deployment.apps/my-app created</code></pre></li><li><code>kubectl delete</code>&nbsp;- This command allows you to delete objects from your Kubernetes cluster. For example, you can use&nbsp;<code>kubectl delete deployment &lt;deployment-name&gt;</code>&nbsp;to delete a deployment and all the replicas it manages.Example output:<pre><code class="language-shell">$ kubectl delete deployment my-app
deployment.apps "my-app" deleted</code></pre></li><li><code>kubectl scale</code>&nbsp;- This command allows you to change the number of replicas in a deployment. For example, you can use&nbsp;<code>kubectl scale deployment &lt;deployment-name&gt; --replicas=3</code>&nbsp;to scale a deployment to run 3 replicas of the specified Docker image.Example output:<pre><code class="language-shell">$ kubectl scale deployment my-app --replicas=3
deployment.apps/my-app scaled</code></pre></li><li><code>kubectl apply</code>&nbsp;- This command allows you to apply changes to your Kubernetes cluster. For example, you can use&nbsp;<code>kubectl apply -f &lt;config-file.yaml&gt;</code>&nbsp;to apply the changes specified in a YAML configuration file to your cluster.Example output:<pre><code class="language-shell">$ kubectl apply -f my-app-config.yaml
deployment.apps/my-app configured</code></pre></li><li><code>kubectl exec</code>&nbsp;- This command allows you to run a command inside a container in a pod. For example, you can use&nbsp;<code>kubectl exec -it &lt;pod-name&gt; -- bash</code>&nbsp;to open a Bash shell inside a container in a specific pod.Example output:<pre><code class="language-shell">$ kubectl exec -it my-app-7c5f9fd5b8-2lkf7 -- bash
root@my-app-7c5f9fd5b8-2lkf7:/#</code></pre></li><li><code>kubectl logs</code>&nbsp;- This command allows you to retrieve the logs from a container in a pod. For example, you can use&nbsp;<code>kubectl logs &lt;pod-name&gt;</code>&nbsp;to get the logs from all the containers in a specific pod.Example output:<pre><code class="language-shell">$ kubectl logs my-app-7c5f9fd5b8-2lkf7
2019-09-15 18:42:24,123 INFO Starting my-app version 1.0.0
2019-09-15 18:42:24,123 INFO Listening on port 8080</code></pre></li><li><code>kubectl port-forward</code>&nbsp;- This command allows you to forward a local port to a port on a pod. For example, you can use&nbsp;<code>kubectl port-forward &lt;pod-name&gt; 8080:80</code>&nbsp;to forward local port 8080 to port 80 on the specified pod.Example output:<pre><code class="language-shell">$ kubectl port-forward my-app-7c5f9fd5b8-2lkf7 8080:80
Forwarding from 127.0.0.1:8080 -&gt; 80
Forwarding from [::1]:8080 -&gt; 80</code></pre></li><li><code>kubectl rollout</code> - This command allows you to manage the rollout of a deployment or other resource type in a Kubernetes cluster. For example, you can use <code>kubectl rollout status deployment &lt;deployment-name&gt;</code> to check the status of a deployment:Example output:<pre><code class="language-shell">$ kubectl rollout status deployment my-deployment
deployment "my-deployment" successfully rolled out</code></pre></li></ol>In my opinion these 10 commands are essential for any DevOps Engineer or anyone who works with Kubernetes. They provide the basic functionality needed to manage and deploy applications on a Kubernetes cluster. By using these commands, you can easily retrieve information about your cluster, create and delete objects, and apply changes to your applications.