aws_rest/README.md

## AWS REST Web Service

Instrukcja uruchomienia web serwisu RESTowego na platformie AWS przy użyciu `AWS Lambda`, `API Gateway` oraz `DynamoDB`:

1. Utwórz tabelę w `DynamoDB`:
    - Przejdź do konsoli AWS i wybierz usługę `DynamoDB`.
    - Kliknij przycisk `Create table`.
    - Wprowadź nazwę tabeli: `Posts`.
    - Wprowadź klucz główny: `id` typu `String`.
    - Kliknij przycisk `Create`.

2. Utwórz funkcję w `AWS Lambda` do obsługi żądań `CRUD`:
    - Przejdź do konsoli AWS i wybierz usługę `Lambda`.
    - Kliknij przycisk `Create function`.
    - Wybierz opcję `Author from scratch`.
    - Wprowadź nazwę funkcji, np. `postsCRUD`.
    - Wybierz runtime, np. `Python 3.13`.
    - W sekcji `Change default execution role` wybierz opcję `Use an existing role` i wybierz rolę `LabRole`.
    - Kliknij przycisk `Create function`.
    - Wklej poniższy kod do edytora funkcji:
    ```python
   import json
   import boto3
   from decimal import Decimal
   
   dynamodb = boto3.resource("dynamodb")
   table = dynamodb.Table('Posts')
   
   
   def lambda_handler(event, context):
       print(event)
       body = {}
       statusCode = 200

    try:
        # Endpoint: DELETE /posts/{id}
        if event['routeKey'] == "DELETE /posts/{id}":
            table.delete_item(
                Key={'id': event['pathParameters']['id']}  # id jako string
            )
            body = {"message": f"Deleted item with id {event['pathParameters']['id']}"}

        # Endpoint: GET /posts/{id}
        elif event['routeKey'] == "GET /posts/{id}":
            response = table.get_item(
                Key={'id': event['pathParameters']['id']}  # id jako string
            )
            if 'Item' in response:
                body = response['Item']
            else:
                statusCode = 404
                body = {"error": "Item not found"}

        # Endpoint: GET /posts
        elif event['routeKey'] == "GET /posts":
            response = table.scan()
            items = response.get('Items', [])
            body = items

        # Endpoint: POST /posts (automatyczne generowanie id)
        elif event['routeKey'] == "POST /posts":
            requestJSON = json.loads(event['body'])

            # Pobierz największe istniejące id
            response = table.scan()
            items = response.get('Items', [])
            max_id = max((int(item['id']) for item in items if item['id'].isdigit()), default=0)

            # Wygeneruj nowe id
            new_id = str(max_id + 1)

            # Utwórz nowy wpis
            new_item = {
                'id': new_id,
                'userId': str(requestJSON['userId']),
                'title': requestJSON['title'],
                'body': requestJSON['body']
            }
            table.put_item(Item=new_item)

            # Zwróć utworzony obiekt w odpowiedzi
            body = new_item

        # Endpoint: PUT /posts/{id}
        elif event['routeKey'] == "PUT /posts/{id}":
            requestJSON = json.loads(event['body'])

            # Aktualizacja danych w tabeli
            table.update_item(
                Key={'id': event['pathParameters']['id']},  # id jako string
                UpdateExpression="SET userId = :userId, title = :title, body = :body",
                ExpressionAttributeValues={
                    ':userId': str(requestJSON['userId']),
                    ':title': requestJSON['title'],
                    ':body': requestJSON['body']
                }
            )

            # Pobranie zaktualizowanego obiektu
            response = table.get_item(
                Key={'id': event['pathParameters']['id']}
            )
            if 'Item' in response:
                body = response['Item']
            else:
                statusCode = 404
                body = {"error": "Updated item not found"}

        # Unsupported route
        else:
            statusCode = 400
            body = {"error": f"Unsupported route: {event['routeKey']}"}

    except Exception as e:
        statusCode = 500
        body = {"error": str(e)}

    # Return the response
    return {
        "statusCode": statusCode,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": json.dumps(body)
    }
    ```

3. Utwórz HTTP API w `API Gateway` do przekierowywania żądań do funkcji `AWS Lambda`:
    - Przejdź do konsoli AWS i wybierz usługę `API Gateway`.
    - Kliknij przycisk `Create API`.
    - Wybierz opcję `HTTP API`.
    - Wprowadź nazwę API, np. `PostsAPI`.
    - Przejdź przez formularz i utwórz API.
    - Utwórz endpointy dla żądań `GET`, `POST`, `PUT` i `DELETE`, np.:
    ```
    GET /posts
    GET /posts/{id}
    POST /posts
    PUT /posts/{id}
    DELETE /posts/{id}
    ```
   - Utwórz i przypisz integrację z funkcją `AWS Lambda` dla każdego endpointu (wybierz utworzoną wcześniej funkcję).

4. I gotowe. Możesz teraz uruchomić skrypt testowy `test.ipynb` do testowania web serwisu RESTowego. Pamiętaj, by zmienić adres URL API w skrypcie na Twój adres URL.

### Materiały
* https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-dynamo-db.html#http-api-dynamo-db-create-table