get all done

Author: HarshCasper

src/content/docs/aws/services/ssm.md

@@ -1,6 +1,5 @@
 ---
 title: "Systems Manager (SSM)"
-linkTitle: "Systems Manager (SSM)"
 description: Get started with Systems Manager (SSM) on LocalStack
 tags: ["Free"]
 persistence: supported
@@ -12,7 +11,7 @@ Systems Manager (SSM) is a management service provided by Amazon Web Services th
 SSM simplifies tasks related to system and application management, patching, configuration, and automation, allowing you to maintain the health and compliance of your environment.
 
 LocalStack allows you to use the SSM APIs in your local environment to run operational tasks on the Dockerized instances.
-The supported APIs are available on our [API coverage page]({{< ref "coverage_ssm" >}}), which provides information on the extent of SSM's integration with LocalStack.
+The supported APIs are available on our [API coverage page](), which provides information on the extent of SSM's integration with LocalStack.
 
 ## Getting started
 
@@ -27,20 +26,20 @@ To get started, pull the `ubuntu:focal` image from Docker Hub and tag it as `loc
 LocalStack uses a naming scheme to recognise and manage the containers and images associated with it.
 The container are named `localstack-ec2.<InstanceId>`, while images are tagged `localstack-ec2/<AmiName>:<AmiId>`.
 
-{{< command >}}
-$ docker pull ubuntu:focal
-$ docker tag ubuntu:focal localstack-ec2/ubuntu-focal-docker-ami:ami-00a001
-{{< / command >}}
+```bash
+docker pull ubuntu:focal
+docker tag ubuntu:focal localstack-ec2/ubuntu-focal-docker-ami:ami-00a001
+```
 
 LocalStack's Docker backend treats Docker images with the above naming scheme as AMIs.
 The AMI ID is the last part of the image tag, `ami-00a001` in this case.
 You can run an EC2 instance using the [`RunInstances`](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RunInstances.html) API.
 Execute the following command to create an EC2 instance using the `ami-00a001` AMI.
 
-{{< command >}}
-$ awslocal ec2 run-instances \
+```bash
+awslocal ec2 run-instances \
  --image-id ami-00a001 --count 1
-{{< / command >}}
+```
 
 The following output would be retrieved:
 
@@ -71,12 +70,12 @@ You can copy the `InstanceId` value and use it in the following commands.
 You can use the [`SendCommand`](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_SendCommand.html) API to send a command to the EC2 instance.
 The following command sends a `cat lsb-release` command in the `/etc` directory to the EC2 instance.
 
-{{< command >}}
-$ awslocal ssm send-command --document-name "AWS-RunShellScript" \
+```bash
+awslocal ssm send-command --document-name "AWS-RunShellScript" \
  --document-version "1" \
  --instance-ids i-abf6920789a06dd84 \
  --parameters "commands='cat lsb-release',workingDirectory=/etc"
-{{< / command >}}
+```
 
 The following output would be retrieved:
 
@@ -101,11 +100,11 @@ You can copy the `CommandId` value and use it in the following commands.
 You can use the [`GetCommandInvocation`](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetCommandInvocation.html) API to retrieve the command output.
 The following command retrieves the output of the command sent in the previous step.
 
-{{< command >}}
-$ awslocal ssm get-command-invocation \
+```bash
+awslocal ssm get-command-invocation \
  --command-id 23547a9b-6993-4967-9446-f96b9b5dac70 \
  --instance-id i-abf6920789a06dd84
-{{< / command >}}
+```
 
 Change the `CommandId` and `InstanceId` values to the ones you received in the previous step.
 The following output would be retrieved:
@@ -127,7 +126,7 @@ The following output would be retrieved:
 The LocalStack Web Application provides a Resource Browser for managing SSM System Parameters.
 You can access the Resource Browser by opening the LocalStack Web Application in your browser, navigating to the **Resource Browser** section, and then clicking on **Simple Systems Manager (SSM)** under the **Management/Governance** section.
 
-<img src="ssm-resource-browser.png" alt="SSM Resource Browser" title="SSM Resource Browser" width="900" />
+![SSM Resource Browser](/images/aws/ssm-resource-browser.png)
 
 The Resource Browser allows you to perform the following actions:
 

src/content/docs/aws/services/stepfunctions.md renamed to src/content/docs/aws/services/stepfunctions.mdx

@@ -1,9 +1,7 @@
 ---
 title: "Step Functions"
-linkTitle: "Step Functions"
 tags: ["Free"]
-description: >
- Get started with Step Functions on LocalStack
+description: Get started with Step Functions on LocalStack
 ---
 
 ## Introduction
@@ -13,7 +11,7 @@ It provides a JSON-based structured language called Amazon States Language (ASL)
 Thus making it easier to build and maintain complex and distributed applications.
 
 LocalStack allows you to use the Step Functions APIs in your local environment to create, execute, update, and delete state machines locally.
-The supported APIs are available on our [API coverage page]({{< ref "coverage_stepfunctions" >}}), which provides information on the extent of Step Function's integration with LocalStack.
+The supported APIs are available on our [API coverage page](), which provides information on the extent of Step Function's integration with LocalStack.
 
 ## Getting started
 
@@ -28,8 +26,8 @@ You can create a state machine using the [`CreateStateMachine`](https://docs.aws
 The API requires the name of the state machine, the state machine definition, and the role ARN that the state machine will assume to call AWS services.
 Run the following command to create a state machine:
 
-{{< command >}}
-$ awslocal stepfunctions create-state-machine \
+```bash
+awslocal stepfunctions create-state-machine \
  --name "CreateAndListBuckets" \
  --definition '{
  "Comment": "Create bucket and list buckets",
@@ -51,7 +49,7 @@ $ awslocal stepfunctions create-state-machine \
  }
  }' \
  --role-arn "arn:aws:iam::000000000000:role/stepfunctions-role"
-{{< /command >}}
+```
 
 The output of the above command is the ARN of the state machine:
 
@@ -68,10 +66,10 @@ You can execute the state machine using the [`StartExecution`](https://docs.aws.
 The API requires the state machine's ARN and the state machine's input.
 Run the following command to execute the state machine:
 
-{{< command >}}
-$ awslocal stepfunctions start-execution \
+```bash
+awslocal stepfunctions start-execution \
  --state-machine-arn "arn:aws:states:us-east-1:000000000000:stateMachine:CreateAndListBuckets"
-{{< /command >}}
+```
 
 The output of the above command is the execution ARN:
 
@@ -87,10 +85,10 @@ The output of the above command is the execution ARN:
 To check the status of the execution, you can use the [`DescribeExecution`](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) API.
 Run the following command to describe the execution:
 
-{{< command >}}
-$ awslocal stepfunctions describe-execution \
+```bash
+awslocal stepfunctions describe-execution \
  --execution-arn "arn:aws:states:us-east-1:000000000000:execution:CreateAndListBuckets:bf7d2138-e96f-42d1-b1f9-41f0c1c7bc3e"
-{{< /command >}}
+```
 
 Replace the `execution-arn` with the ARN of the execution you want to describe.
 
@@ -161,10 +159,10 @@ LocalStack can also serve as a drop-in replacement for [AWS Step Functions Local
 It supports test cases with mocked Task states and maintains compatibility with existing Step Functions Local configurations.
 This functionality is extended in LocalStack by providing access to the latest Step Functions features such as [JSONata and Variables](https://blog.localstack.cloud/aws-step-functions-made-easy/), as well as the ability to enable both mocked and emulated service interactions emulated by LocalStack.
 
-{{< callout >}}
+:::note
 LocalStack does not validate response formats.
 Ensure the payload structure in the mocked responses matches what the real service expects.
-{{< /callout >}}
+:::
 
 ### Identify a State Machine for Mocked Integrations
 
@@ -287,9 +285,9 @@ In the example above:
 - `Return`: Simulates a successful response by returning a predefined payload. 
 - `Throw`: Simulates a failure by returning an `Error` and an optional `Cause`.
 
-{{< callout >}}
+:::note
 Each entry must have **either** `Return` or `Throw`, but cannot have both.
-{{< /callout >}}
+:::
 
 Here is a complete example of the `MockedResponses` section:
 
@@ -390,12 +388,17 @@ Set the `SFN_MOCK_CONFIG` environment variable to the path of your mock configur
 
 If you're running LocalStack in Docker, mount the file and pass the variable as shown below:
 
-{{< tabpane >}}
-{{< tab header="LocalStack CLI" lang="shell" >}}
+import { Tabs, TabItem } from '@astrojs/starlight/components';
+
+<Tabs>
+<TabItem label="LocalStack CLI">
+```bash
 LOCALSTACK_SFN_MOCK_CONFIG=/tmp/MockConfigFile.json \
 localstack start --volume /path/to/MockConfigFile.json:/tmp/MockConfigFile.json
-{{< /tab >}}
-{{< tab header="Docker Compose" lang="yaml" >}}
+```
+</TabItem>
+<TabItem label="Docker Compose"> 
+```yaml
 services:
  localstack:
  container_name: "${LOCALSTACK_DOCKER_NAME:-localstack-main}"
@@ -411,21 +414,22 @@ services:
  - "${LOCALSTACK_VOLUME_DIR:-./volume}:/var/lib/localstack"
  - "/var/run/docker.sock:/var/run/docker.sock"
  - "./MockConfigFile.json:/tmp/MockConfigFile.json"
-{{< /tab >}}
-{{< /tabpane >}}
+```
+</TabItem>
+</Tabs>
 
 ### Run Test Cases with Mocked Integrations
 
 Create the state machine to match the name defined in the mock configuration file. 
 
 In this example, create the `LambdaSQSIntegration` state machine using:
 
-{{< command >}}
-$ awslocal stepfunctions create-state-machine \
+```bash
+awslocal stepfunctions create-state-machine \
  --definition file://LambdaSQSIntegration.json \
  --name "LambdaSQSIntegration" \
  --role-arn "arn:aws:iam::000000000000:role/service-role/testrole"
-{{< /command >}}
+```
 
 After the state machine is created and correctly named, you can run test cases defined in the mock configuration file using the [`StartExecution`](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html) API.
 
@@ -435,22 +439,22 @@ This tells LocalStack to apply the corresponding mocked responses from the confi
 
 For example, to run the `BaseCase` test case:
 
-{{< command >}}
-$ awslocal stepfunctions start-execution \
+```bash
+awslocal stepfunctions start-execution \
  --state-machine arn:aws:states:us-east-1:000000000000:stateMachine:LambdaSQSIntegration#BaseCase \
  --input '{"name": "John", "surname": "smith"}' \
  --name "MockExecutionBaseCase"
-{{< /command >}}
+```
 
 During execution, any state mapped in the mock config will use the predefined response. 
 States without mock entries invoke the actual emulated service as usual.
 
 You can inspect the execution using the [`DescribeExecution`](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) API:
 
-{{< command >}}
-$ awslocal stepfunctions describe-execution \
+```bash
+awslocal stepfunctions describe-execution \
  --execution-arn "arn:aws:states:us-east-1:000000000000:execution:LambdaSQSIntegration:MockExecutionBaseCase"
-{{< /command >}}
+```
 
 The sample output shows the execution details, including the state machine ARN, execution ARN, status, start and stop dates, input, and output:
 
@@ -475,10 +479,10 @@ The sample output shows the execution details, including the state machine ARN,
 
 You can also use the [`GetExecutionHistory`](https://docs.aws.amazon.com/step-functions/latest/apireference/API_GetExecutionHistory.html) API to retrieve the execution history, including the events and their details.
 
-{{< command >}}
-$ awslocal stepfunctions get-execution-history \
+```bash
+awslocal stepfunctions get-execution-history \
  --execution-arn "arn:aws:states:us-east-1:000000000000:execution:LambdaSQSIntegration:MockExecutionBaseCase"
-{{< /command >}}
+```
 
 This will return the full execution history, including entries that indicate how mocked responses were applied to Lambda and SQS states.
 
@@ -522,9 +526,7 @@ The LocalStack Web Application includes a **Resource Browser** for managing Step
 
 To access it, open the LocalStack Web UI in your browser, navigate to the **Resource Browser** section, and click **Step Functions** under **App Integration**.
 
-<img src="stepfunctions-resource-browser.png" alt="Step Functions Resource Browser" title="Step Functions Resource Browser" width="900" />
-<br>
-<br>
+![Step Functions Resource Browser](/images/aws/stepfunctions-resource-browser.png)
 
 The Resource Browser allows you to perform the following actions:
 

src/content/docs/aws/services/sts.md

@@ -1,6 +1,5 @@
 ---
 title: "Security Token Service (STS)"
-linkTitle: "Security Token Service (STS)"
 description: Get started with Security Token Service on LocalStack
 persistence: supported
 tags: ["Free"]
@@ -13,7 +12,7 @@ STS implements fine-grained access control and reduce the exposure of your long-
 The temporary credentials, known as security tokens, can be used to access AWS services and resources based on the permissions specified in the associated policies.
 
 LocalStack allows you to use the STS APIs in your local environment to request security tokens, manage permissions, integrate with identity providers, and more.
-The supported APIs are available on our [API coverage page]({{< ref "coverage_sts" >}}), which provides information on the extent of STS's integration with LocalStack.
+The supported APIs are available on our [API coverage page](), which provides information on the extent of STS's integration with LocalStack.
 
 ## Getting started
 
@@ -28,18 +27,18 @@ You can create an IAM User and Role using the [`CreateUser`](https://docs.aws.am
 The IAM User will be used to assume the IAM Role.
 Run the following command to create an IAM User, named `localstack-user`:
 
-{{< command >}}
-$ awslocal iam create-user \
+```bash
+awslocal iam create-user \
  --user-name localstack-user
-{{< /command >}}
+```
 
 You can generate long-term access keys for the IAM user using the [`CreateAccessKey`](https://docs.aws.amazon.com/STS/latest/APIReference/API_CreateAccessKey.html) API.
 Run the following command to create an access key for the IAM user:
 
-{{< command >}}
-$ awslocal iam create-access-key \
+```bash
+awslocal iam create-access-key \
  --user-name localstack-user
-{{< /command >}}
+```
 
 The following output would be retrieved:
 
@@ -58,9 +57,9 @@ The following output would be retrieved:
 Using STS, you can also fetch temporary credentials for this user using the [`GetSessionToken`](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html) API.
 Run the following command using your long-term credentials to get your temporary credentials:
 
-{{< command >}}
-$ awslocal sts get-session-token
-{{< /command >}}
+```bash
+awslocal sts get-session-token
+```
 
 The following output would be retrieved:
 
@@ -80,11 +79,11 @@ The following output would be retrieved:
 You can now create an IAM Role, named `localstack-role`, using the [`CreateRole`](https://docs.aws.amazon.com/STS/latest/APIReference/API_CreateRole.html) API.
 Run the following command to create the IAM Role:
 
-{{< command >}}
-$ awslocal iam create-role \
+```bash
+awslocal iam create-role \
  --role-name localstack-role \
  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::000000000000:root"},"Action":"sts:AssumeRole"}]}'
-{{< /command >}}
+```
 
 The following output would be retrieved:
 
@@ -115,22 +114,22 @@ The following output would be retrieved:
 You can attach the policy to the IAM role using the [`AttachRolePolicy`](https://docs.aws.amazon.com/STS/latest/APIReference/API_AttachRolePolicy.html) API.
 Run the following command to attach the policy to the IAM role:
 
-{{< command >}}
-$ awslocal iam attach-role-policy \
+```bash
+awslocal iam attach-role-policy \
  --role-name localstack-role \
  --policy-arn arn:aws:iam::aws:policy/AdministratorAccess
-{{< /command >}}
+```
 
 ### Assume an IAM Role
 
 You can assume an IAM Role using the [`AssumeRole`](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) API.
 Run the following command to assume the IAM Role:
 
-{{< command >}}
-$ awslocal sts assume-role \
+```bash
+awslocal sts assume-role \
  --role-arn arn:aws:iam::000000000000:role/localstack-role \
  --role-session-name localstack-session
-{{< /command >}}
+```
 
 The following output would be retrieved:
 
@@ -157,9 +156,9 @@ You can use the temporary credentials in your applications for temporary access.
 You can get the caller identity to identify the principal your current credentials are valid for using the [`GetCallerIdentity`](https://docs.aws.amazon.com/STS/latest/APIReference/API_GetCallerIdentity.html) API.
 Run the following command to get the caller identity for the credentials set in your environment:
 
-{{< command >}}
-$ awslocal sts get-caller-identity
-{{< /command >}}
+```bash
+awslocal sts get-caller-identity
+```
 
 The following output would be retrieved: