Mulai Menggunakan Amazon Q Developer CLI dengan Membuat Game: Panduan Langkah Demi Langkah

Selamat datang di panduan lengkap untuk memulai menggunakan Amazon Q Developer CLI dengan pendekatan praktis: membangun game sederhana. Dalam artikel ini, kita akan membahas cara menginstal, mengonfigurasi, dan menggunakan Amazon Q Developer CLI untuk menyederhanakan proses pengembangan Anda, sembari membangun game sederhana untuk mengilustrasikan fitur-fiturnya. Dengan mengikuti langkah-langkah ini, Anda akan memahami bagaimana alat ini dapat meningkatkan produktivitas Anda dan mempercepat alur kerja pengembangan Anda.

Mengapa Memilih Amazon Q Developer CLI?

Amazon Q Developer CLI adalah alat baris perintah yang dirancang untuk menyederhanakan interaksi Anda dengan layanan AWS dan membantu Anda membangun, menguji, dan menerapkan aplikasi Anda dengan lebih efisien. Beberapa manfaat utama meliputi:

• Akses Terpusat: Mengelola dan berinteraksi dengan berbagai layanan AWS dari satu antarmuka.
• Automasi: Otomatisasi tugas-tugas umum seperti penerapan, konfigurasi, dan pengujian.
• Produktivitas: Meningkatkan produktivitas dengan menyediakan perintah cepat dan mudah digunakan.
• Kolaborasi: Memfasilitasi kolaborasi dengan menyediakan cara yang konsisten untuk mengelola infrastruktur dan kode.

Kerangka Artikel

1. Pendahuluan: Apa itu Amazon Q Developer CLI dan mengapa Anda harus menggunakannya?
2. Prasyarat: Alat dan akun yang diperlukan.
3. Instalasi dan Konfigurasi: Panduan langkah demi langkah untuk menginstal dan mengkonfigurasi Amazon Q Developer CLI.
4. Membuat Game Sederhana:
   1. Memilih Framework/Library Game (misalnya, Phaser.js, Pygame).
   2. Menyiapkan Proyek Game.
   3. Mengimplementasikan Logika Game Dasar.
   4. Mengintegrasikan dengan Layanan AWS (misalnya, penyimpanan skor menggunakan DynamoDB).
5. Menggunakan Amazon Q Developer CLI untuk Otomatisasi:
   1. Penerapan Aplikasi ke AWS (misalnya, menggunakan AWS Lambda dan API Gateway).
   2. Mengelola Sumber Daya AWS.
   3. Mengotomatiskan Pengujian.
6. Praktik Terbaik: Tips untuk memaksimalkan Amazon Q Developer CLI.
7. Pemecahan Masalah: Solusi untuk masalah umum.
8. Kesimpulan: Ringkasan dan langkah selanjutnya.

1. Pendahuluan: Apa itu Amazon Q Developer CLI?

Amazon Q Developer CLI adalah antarmuka baris perintah (CLI) yang kuat dan serbaguna yang dirancang untuk membantu pengembang mengelola dan berinteraksi dengan layanan Amazon Web Services (AWS) dengan lebih efisien. Ini menyediakan serangkaian perintah yang disederhanakan yang memungkinkan Anda untuk mengotomatiskan tugas-tugas umum, mengelola sumber daya AWS, dan mempercepat alur kerja pengembangan Anda. Singkatnya, ini adalah “Swiss Army Knife” untuk pengembang yang bekerja di ekosistem AWS.

Bayangkan skenario di mana Anda secara rutin perlu menerapkan aplikasi, mengonfigurasi sumber daya, menjalankan pengujian, dan memantau kinerja aplikasi Anda. Tanpa alat seperti Amazon Q Developer CLI, Anda mungkin perlu beralih di antara berbagai konsol web AWS, menulis skrip yang rumit, atau menggunakan berbagai alat baris perintah yang terpisah. Proses ini tidak hanya memakan waktu tetapi juga rentan terhadap kesalahan.

Amazon Q Developer CLI mengatasi tantangan ini dengan menyediakan antarmuka terpadu untuk mengelola semua aspek infrastruktur AWS Anda. Dengan beberapa perintah sederhana, Anda dapat melakukan tugas-tugas kompleks seperti:

• Menerapkan aplikasi ke berbagai layanan AWS seperti AWS Lambda, Amazon EC2, dan AWS Elastic Beanstalk.
• Mengelola sumber daya AWS seperti bucket Amazon S3, tabel Amazon DynamoDB, dan fungsi AWS Lambda.
• Mengotomatiskan pengujian dengan menjalankan pengujian unit, pengujian integrasi, dan pengujian end-to-end.
• Memantau kinerja aplikasi Anda dengan mengumpulkan metrik dan log dari berbagai layanan AWS.

Dengan mengotomatiskan tugas-tugas ini, Amazon Q Developer CLI membantu Anda menghemat waktu, mengurangi kesalahan, dan meningkatkan produktivitas Anda. Ini juga memfasilitasi kolaborasi yang lebih baik di antara anggota tim dengan menyediakan cara yang konsisten dan dapat diprediksi untuk mengelola infrastruktur dan kode.

Dalam panduan ini, kita akan menjelajahi berbagai fitur Amazon Q Developer CLI melalui pendekatan praktis: membangun game sederhana. Pendekatan ini akan memungkinkan Anda untuk melihat secara langsung bagaimana alat ini dapat digunakan untuk menyederhanakan alur kerja pengembangan Anda dan meningkatkan produktivitas Anda.

Mengapa Anda Harus Menggunakan Amazon Q Developer CLI?

Ada banyak alasan mengapa Anda harus mempertimbangkan untuk menggunakan Amazon Q Developer CLI dalam alur kerja pengembangan Anda. Berikut adalah beberapa manfaat utama:

• Peningkatan Produktivitas: Otomatisasi tugas-tugas yang membosankan dan berulang, membebaskan Anda untuk fokus pada tugas-tugas yang lebih penting.
• Alur Kerja yang Disederhanakan: Menyediakan antarmuka terpadu untuk mengelola semua aspek infrastruktur AWS Anda.
• Pengurangan Kesalahan: Mengurangi risiko kesalahan manusia dengan mengotomatiskan tugas-tugas dan menyediakan cara yang konsisten untuk mengelola sumber daya.
• Kolaborasi yang Lebih Baik: Memfasilitasi kolaborasi di antara anggota tim dengan menyediakan cara yang konsisten dan dapat diprediksi untuk mengelola infrastruktur dan kode.
• Akses Mudah ke Layanan AWS: Menyederhanakan interaksi dengan berbagai layanan AWS, memungkinkan Anda untuk memanfaatkan kekuatan AWS dengan lebih mudah.
• Penerapan yang Lebih Cepat: Mempercepat proses penerapan dengan mengotomatiskan langkah-langkah yang terlibat dalam penerapan aplikasi ke AWS.
• Pengelolaan Sumber Daya yang Lebih Mudah: Memudahkan pengelolaan sumber daya AWS dengan menyediakan perintah yang sederhana dan mudah digunakan.
• Pengujian yang Ditingkatkan: Memungkinkan Anda untuk mengotomatiskan pengujian dan memastikan bahwa aplikasi Anda berkualitas tinggi.
• Pemantauan yang Lebih Baik: Memudahkan pemantauan kinerja aplikasi Anda dengan mengumpulkan metrik dan log dari berbagai layanan AWS.

Secara keseluruhan, Amazon Q Developer CLI adalah alat yang berharga bagi setiap pengembang yang bekerja di ekosistem AWS. Dengan menyederhanakan interaksi Anda dengan layanan AWS dan mengotomatiskan tugas-tugas umum, ini dapat membantu Anda menghemat waktu, mengurangi kesalahan, dan meningkatkan produktivitas Anda.

2. Prasyarat

Sebelum kita mulai menggunakan Amazon Q Developer CLI, ada beberapa prasyarat yang perlu Anda penuhi. Ini memastikan bahwa Anda memiliki semua alat dan akun yang diperlukan untuk mengikuti tutorial ini dan membangun game sederhana Anda.

1. Akun AWS: Anda memerlukan akun AWS aktif. Jika Anda belum memiliki akun, Anda dapat mendaftar untuk akun AWS gratis di situs web AWS. Perlu diingat bahwa meskipun AWS menawarkan tingkat gratis, beberapa layanan dan sumber daya mungkin dikenakan biaya.
2. AWS CLI (Command Line Interface): Amazon Q Developer CLI bergantung pada AWS CLI. Pastikan Anda telah menginstal dan mengkonfigurasi AWS CLI pada sistem Anda. Ikuti langkah-langkah di bawah ini untuk menginstal dan mengkonfigurasi AWS CLI:
   • Instal AWS CLI: Anda dapat mengunduh dan menginstal AWS CLI dari situs web AWS. Ikuti instruksi instalasi untuk sistem operasi Anda.
   • Konfigurasi AWS CLI: Setelah menginstal AWS CLI, Anda perlu mengkonfigurasinya dengan kredensial AWS Anda. Jalankan perintah `aws configure` dan ikuti petunjuk untuk memasukkan ID kunci akses AWS, kunci akses rahasia AWS, wilayah AWS default, dan format output default. Pastikan pengguna IAM yang Anda gunakan memiliki izin yang memadai untuk berinteraksi dengan layanan AWS yang akan Anda gunakan (misalnya, membuat fungsi Lambda, mengakses DynamoDB).
3. Python 3.6 atau Lebih Tinggi: Amazon Q Developer CLI ditulis dalam Python, jadi Anda memerlukan Python 3.6 atau yang lebih tinggi yang terinstal pada sistem Anda. Anda dapat mengunduh Python dari situs web Python.
4. Pip (Python Package Installer): Pip biasanya disertakan dengan instalasi Python. Pastikan Anda memiliki Pip yang terinstal dan diperbarui. Anda dapat memperbarui Pip dengan menjalankan perintah `pip install –upgrade pip`.
5. Node.js dan NPM (Node Package Manager): Jika Anda memilih untuk menggunakan kerangka kerja JavaScript seperti Phaser.js untuk game Anda, Anda akan memerlukan Node.js dan NPM yang terinstal. Anda dapat mengunduh dan menginstal Node.js dari situs web Node.js. NPM biasanya disertakan dengan instalasi Node.js.
6. Kerangka Kerja/Library Game (Opsional): Anda dapat memilih kerangka kerja atau library game apa pun yang Anda suka. Dalam contoh ini, kita akan mempertimbangkan Phaser.js (JavaScript) atau Pygame (Python). Anda dapat menginstal Phaser.js menggunakan NPM (`npm install phaser`) atau Pygame menggunakan Pip (`pip install pygame`).
7. Editor Teks atau IDE: Anda memerlukan editor teks atau IDE untuk menulis kode Anda. Beberapa opsi populer termasuk Visual Studio Code, Sublime Text, dan PyCharm.

Setelah Anda memenuhi semua prasyarat ini, Anda siap untuk menginstal dan mengkonfigurasi Amazon Q Developer CLI dan mulai membangun game sederhana Anda.

3. Instalasi dan Konfigurasi

Sekarang setelah kita memenuhi semua prasyarat, mari kita instal dan konfigurasi Amazon Q Developer CLI. Langkah-langkah ini akan memastikan bahwa Anda memiliki alat yang terinstal dan dikonfigurasi dengan benar untuk digunakan dengan akun AWS Anda.

1. Instal Amazon Q Developer CLI menggunakan Pip:

   Buka terminal atau command prompt Anda dan jalankan perintah berikut:

   pip install amazon-q-developer-cli

   Ini akan mengunduh dan menginstal Amazon Q Developer CLI dari PyPI (Python Package Index). Pastikan Anda menjalankan perintah ini di lingkungan virtual Python yang diaktifkan jika Anda menggunakan lingkungan virtual.

2. Verifikasi Instalasi:

   Setelah instalasi selesai, Anda dapat memverifikasi bahwa Amazon Q Developer CLI terinstal dengan benar dengan menjalankan perintah berikut:

   amazon-q --version

   Ini akan menampilkan versi Amazon Q Developer CLI yang terinstal pada sistem Anda. Jika perintah tidak dikenali, pastikan direktori instalasi Python Anda (misalnya, `~/.local/bin` atau direktori `Scripts` di lingkungan virtual) ditambahkan ke variabel PATH sistem Anda.

3. Konfigurasi Amazon Q Developer CLI:

   Amazon Q Developer CLI menggunakan kredensial AWS yang telah Anda konfigurasi menggunakan AWS CLI. Namun, Anda mungkin perlu mengkonfigurasi profil default atau menentukan profil yang akan digunakan.

   Untuk menentukan profil AWS yang akan digunakan, Anda dapat menggunakan variabel lingkungan `AWS_PROFILE`:

   export AWS_PROFILE=nama_profil_anda

   Ganti `nama_profil_anda` dengan nama profil AWS yang ingin Anda gunakan. Anda dapat mengatur ini secara permanen di file konfigurasi shell Anda (misalnya, `.bashrc` atau `.zshrc`).

   Jika Anda hanya menggunakan profil default, Anda tidak perlu mengatur variabel lingkungan `AWS_PROFILE`.

4. Uji Konfigurasi:

   Untuk menguji bahwa Amazon Q Developer CLI dikonfigurasi dengan benar, Anda dapat menjalankan perintah sederhana untuk berinteraksi dengan layanan AWS. Misalnya, Anda dapat mencantumkan bucket S3 Anda:

   amazon-q s3 ls

   Ini akan menampilkan daftar bucket S3 yang ada di akun AWS Anda. Jika Anda menerima kesalahan, periksa kredensial AWS Anda dan pastikan bahwa Anda memiliki izin yang memadai untuk mengakses bucket S3.

Setelah Anda menyelesaikan langkah-langkah ini, Amazon Q Developer CLI Anda akan terinstal dan dikonfigurasi dengan benar. Anda sekarang siap untuk menggunakannya untuk membangun game sederhana Anda dan mengotomatiskan alur kerja pengembangan Anda.

4. Membuat Game Sederhana

Sekarang saatnya untuk membangun game sederhana untuk mengilustrasikan cara menggunakan Amazon Q Developer CLI. Dalam contoh ini, kita akan membuat game sederhana di mana pemain mengontrol objek dan harus menghindari rintangan. Kita akan menggunakan Phaser.js untuk game JavaScript dan Pygame untuk game Python. Anda dapat memilih salah satu, atau kerangka kerja game lain yang Anda kenal.

4.1 Memilih Framework/Library Game

Sebelum kita mulai menulis kode, kita perlu memilih kerangka kerja atau library game. Berikut adalah dua opsi populer:

• Phaser.js: Kerangka kerja JavaScript yang populer untuk membuat game 2D di browser. Ini menyediakan serangkaian fitur yang kaya untuk menangani grafik, input, fisika, dan audio.
• Pygame: Library Python yang populer untuk membuat game. Ini menyediakan serangkaian fungsi untuk menangani grafik, input, audio, dan fisika.

Untuk tutorial ini, kami akan memberikan contoh untuk kedua Phaser.js dan Pygame, sehingga Anda dapat memilih yang paling cocok untuk Anda.

4.2 Menyiapkan Proyek Game

4.2.1 Phaser.js

1. Buat Direktori Proyek: Buat direktori untuk proyek game Anda. Misalnya, Anda dapat membuat direktori bernama `my-phaser-game`.
2. Inisialisasi Proyek NPM: Buka terminal Anda, navigasikan ke direktori proyek Anda, dan jalankan perintah berikut:

   npm init -y

   Ini akan membuat file `package.json` default untuk proyek Anda.

3. Instal Phaser.js: Jalankan perintah berikut untuk menginstal Phaser.js:

   npm install phaser

   Ini akan mengunduh dan menginstal Phaser.js dan dependensinya.

4. Buat File HTML: Buat file HTML bernama `index.html` dan tambahkan kode berikut:

   <!DOCTYPE html>
   <html>
   <head>
     <meta charset="utf-8">
     <title>Phaser Game</title>
   </head>
   <body>
     <script src="node_modules/phaser/dist/phaser.js"></script>
     <script src="src/game.js"></script>
   </body>
   </html>

5. Buat Direktori dan File JavaScript: Buat direktori bernama `src` dan file JavaScript bernama `game.js` di dalam direktori `src`. Ini adalah tempat kita akan menulis logika game kita.

4.2.2 Pygame

1. Buat Direktori Proyek: Buat direktori untuk proyek game Anda. Misalnya, Anda dapat membuat direktori bernama `my-pygame-game`.
2. Buat Lingkungan Virtual (Opsional): Dianjurkan untuk membuat lingkungan virtual untuk proyek Pygame Anda untuk mengisolasi dependensi Anda. Jalankan perintah berikut:

   python3 -m venv venv
   source venv/bin/activate  # Linux/macOS
   venv\Scripts\activate  # Windows

3. Instal Pygame: Jalankan perintah berikut untuk menginstal Pygame:

   pip install pygame

   Ini akan mengunduh dan menginstal Pygame dan dependensinya.

4. Buat File Python: Buat file Python bernama `game.py`. Ini adalah tempat kita akan menulis logika game kita.

4.3 Mengimplementasikan Logika Game Dasar

4.3.1 Phaser.js

Buka file `src/game.js` dan tambahkan kode berikut:

var config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    physics: {
        default: 'arcade',
        arcade: {
            gravity: { y: 300 },
            debug: false
        }
    },
    scene: {
        preload: preload,
        create: create,
        update: update
    }
};

var player;
var platforms;
var cursors;

var game = new Phaser.Game(config);

function preload ()
{
    this.load.image('sky', 'assets/sky.png');
    this.load.image('ground', 'assets/platform.png');
    this.load.image('star', 'assets/star.png');
    this.load.image('bomb', 'assets/bomb.png');
    this.load.spritesheet('dude',
        'assets/dude.png',
        { frameWidth: 32, frameHeight: 48 }
    );
}

function create ()
{
    this.add.image(400, 300, 'sky');

    platforms = this.physics.add.staticGroup();

    platforms.create(400, 568, 'ground').setScale(2).refreshBody();

    platforms.create(600, 400, 'ground');
    platforms.create(50, 250, 'ground');
    platforms.create(750, 220, 'ground');

    player = this.physics.add.sprite(100, 450, 'dude');

    player.setBounce(0.2);
    player.setCollideWorldBounds(true);

    this.anims.create({
        key: 'left',
        frames: this.anims.generateFrameNumbers('dude', { start: 0, end: 3 }),
        frameRate: 10,
        repeat: -1
    });

    this.anims.create({
        key: 'turn',
        frames: [ { key: 'dude', frame: 4 } ],
        frameRate: 20
    });

    this.anims.create({
        key: 'right',
        frames: this.anims.generateFrameNumbers('dude', { start: 5, end: 8 }),
        frameRate: 10,
        repeat: -1
    });

    this.physics.add.collider(player, platforms);

    cursors = this.input.keyboard.createCursorKeys();
}

function update ()
{
    if (cursors.left.isDown)
    {
        player.setVelocityX(-160);

        player.anims.play('left', true);
    }
    else if (cursors.right.isDown)
    {
        player.setVelocityX(160);

        player.anims.play('right', true);
    }
    else
    {
        player.setVelocityX(0);

        player.anims.play('turn');
    }

    if (cursors.up.isDown && player.body.touching.down)
    {
        player.setVelocityY(-330);
    }
}

Anda juga perlu mengunduh aset (gambar) yang digunakan dalam game ini. Anda dapat menemukan aset ini di tutorial Phaser.js resmi atau menggunakan aset Anda sendiri. Tempatkan aset di direktori `assets` di direktori proyek Anda.

4.3.2 Pygame

Buka file `game.py` dan tambahkan kode berikut:

import pygame
import random

# Inisialisasi Pygame
pygame.init()

# Konstanta
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_SPEED = 5
OBSTACLE_SPEED = 3
OBSTACLE_SIZE = 50

# Warna
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)

# Membuat Layar
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Simple Pygame")

# Pemain
player_x = 50
player_y = SCREEN_HEIGHT // 2
player_size = 50

# Rintangan
obstacle_x = SCREEN_WIDTH
obstacle_y = random.randint(0, SCREEN_HEIGHT - OBSTACLE_SIZE)

# Skor
score = 0
font = pygame.font.Font(None, 36)

# Game Loop
running = True
clock = pygame.time.Clock()

while running:
    # Menangani Event
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Input Pemain
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT] and player_x > 0:
        player_x -= PLAYER_SPEED
    if keys[pygame.K_RIGHT] and player_x < SCREEN_WIDTH - player_size:
        player_x += PLAYER_SPEED
    if keys[pygame.K_UP] and player_y > 0:
        player_y -= PLAYER_SPEED
    if keys[pygame.K_DOWN] and player_y < SCREEN_HEIGHT - player_size:
        player_y += PLAYER_SPEED

    # Gerakan Rintangan
    obstacle_x -= OBSTACLE_SPEED
    if obstacle_x < 0:
        obstacle_x = SCREEN_WIDTH
        obstacle_y = random.randint(0, SCREEN_HEIGHT - OBSTACLE_SIZE)
        score += 1

    # Deteksi Tabrakan
    if (player_x < obstacle_x + OBSTACLE_SIZE and
        player_x + player_size > obstacle_x and
        player_y < obstacle_y + OBSTACLE_SIZE and
        player_y + player_size > obstacle_y):
        print("Game Over!")
        running = False

    # Menggambar
    screen.fill(BLACK)
    pygame.draw.rect(screen, WHITE, (player_x, player_y, player_size, player_size))
    pygame.draw.rect(screen, RED, (obstacle_x, obstacle_y, OBSTACLE_SIZE, OBSTACLE_SIZE))

    # Menampilkan Skor
    score_text = font.render(f"Score: {score}", True, WHITE)
    screen.blit(score_text, (10, 10))

    # Memperbarui Layar
    pygame.display.flip()

    # Mengatur Frame Rate
    clock.tick(60)

# Keluar dari Pygame
pygame.quit()

4.4 Mengintegrasikan dengan Layanan AWS (Misalnya, Penyimpanan Skor Menggunakan DynamoDB)

Untuk menunjukkan bagaimana Amazon Q Developer CLI dapat digunakan untuk mengintegrasikan dengan layanan AWS, mari kita implementasikan fitur untuk menyimpan skor game ke Amazon DynamoDB. Ini akan melibatkan membuat tabel DynamoDB dan menggunakan AWS Lambda untuk memperbarui dan mengambil skor.

4.4.1 Membuat Tabel DynamoDB

Anda dapat membuat tabel DynamoDB menggunakan AWS Management Console atau AWS CLI. Untuk tujuan demonstrasi, kita akan membuat tabel bernama `game_scores` dengan atribut berikut:

• `game_id` (String): Kunci Partisi (Misalnya, nama game).
• `user_id` (String): Kunci Pengurutan (ID pengguna).
• `score` (Number): Skor Pengguna.

Gunakan AWS CLI untuk membuat tabel:

aws dynamodb create-table \
    --table-name game_scores \
    --attribute-definitions AttributeName=game_id,AttributeType=S AttributeName=user_id,AttributeType=S \
    --key-schema AttributeName=game_id,KeyType=HASH AttributeName=user_id,KeyType=RANGE \
    --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5

4.4.2 Membuat Fungsi AWS Lambda

Kita akan membuat fungsi AWS Lambda untuk menyimpan skor ke DynamoDB. Kita akan membutuhkan dua fungsi:

• `save_score`: Menyimpan skor baru ke DynamoDB.
• `get_high_scores`: Mengambil skor tertinggi dari DynamoDB.

Mari kita buat fungsi `save_score` terlebih dahulu.

4.4.2.1 Buat Direktori Proyek Lambda

mkdir save_score_lambda
cd save_score_lambda

4.4.2.2 Buat File `lambda_function.py`

import boto3
import json

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('game_scores')

def lambda_handler(event, context):
    try:
        game_id = event['game_id']
        user_id = event['user_id']
        score = event['score']

        response = table.put_item(
           Item={
                'game_id': game_id,
                'user_id': user_id,
                'score': score
            }
        )

        return {
            'statusCode': 200,
            'body': json.dumps('Score saved successfully!')
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps(str(e))
        }

4.4.2.3 Buat File `requirements.txt`

boto3

4.4.2.4 Sebarkan Fungsi Lambda Menggunakan Amazon Q Developer CLI

Anda dapat menyebarkan fungsi Lambda Anda menggunakan perintah berikut:

amazon-q lambda deploy --function-name save_score --runtime python3.8 --handler lambda_function.lambda_handler --memory 128 --timeout 30 --zip-file save_score.zip --iam-role arn:aws:iam::YOUR_ACCOUNT_ID:role/lambda_dynamodb_role

Pastikan Anda mengganti:

• `save_score` dengan nama yang Anda inginkan untuk fungsi Lambda Anda.
• `python3.8` dengan runtime Python yang Anda gunakan.
• `arn:aws:iam::YOUR_ACCOUNT_ID:role/lambda_dynamodb_role` dengan ARN dari peran IAM yang memiliki izin untuk mengakses DynamoDB.
• `save_score.zip` dengan nama file zip yang berisi kode fungsi lambda anda (buat file zip ini dengan perintah `zip -r save_score.zip .`)

Anda perlu membuat peran IAM dengan izin yang diperlukan untuk mengakses DynamoDB. Peran tersebut harus memiliki kebijakan berikut:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "dynamodb:PutItem"
            ],
            "Resource": "arn:aws:dynamodb:YOUR_REGION:YOUR_ACCOUNT_ID:table/game_scores"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:*"
        }
    ]
}

Buat fungsi `get_high_scores` mengikuti langkah-langkah yang sama. Berikut adalah kode untuk `lambda_function.py`:

import boto3
import json

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('game_scores')

def lambda_handler(event, context):
    try:
        game_id = event['game_id']

        response = table.scan(
            FilterExpression=boto3.dynamodb.conditions.Attr('game_id').eq(game_id)
        )

        items = response['Items']
        sorted_items = sorted(items, key=lambda i: i['score'], reverse=True)

        return {
            'statusCode': 200,
            'body': json.dumps(sorted_items)
        }
    except Exception as e:
        return {
            'statusCode': 500,
            'body': json.dumps(str(e))
        }

Pastikan Anda memperbarui peran IAM untuk menyertakan izin untuk melakukan operasi `dynamodb:Scan` pada tabel `game_scores`.

4.4.3 Memperbarui Kode Game

Sekarang kita perlu memperbarui kode game kita untuk memanggil fungsi Lambda dan menyimpan skor. Untuk Phaser.js atau Pygame, ini melibatkan membuat permintaan HTTP ke API Gateway yang memicu fungsi Lambda.

Pertama, kita perlu membuat API Gateway untuk memicu fungsi Lambda.

4.4.3.1 Membuat API Gateway

Anda dapat membuat API Gateway menggunakan AWS Management Console atau AWS CLI. Untuk tujuan demonstrasi, kita akan membuat API Gateway menggunakan konsol.

• Buka konsol AWS API Gateway.
• Klik “Create API”.
• Pilih “REST API” dan klik “Build”.
• Pilih “New API” dan beri nama API Anda (misalnya, `game_scores_api`).
• Klik “Create API”.
• Buat sumber daya bernama `scores`.
• Buat metode `POST` pada sumber daya `scores` dan integrasikan dengan fungsi Lambda `save_score`.
• Buat metode `GET` pada sumber daya `scores` dan integrasikan dengan fungsi Lambda `get_high_scores`.
• Sebarkan API Anda ke panggung (misalnya, `prod`).

Setelah Anda menyebarkan API Anda, Anda akan mendapatkan URL invocation. Anda akan memerlukan ini untuk memanggil API dari kode game Anda.

4.4.3.2 Memperbarui Kode Phaser.js atau Pygame

Anda perlu menambahkan kode ke game Anda untuk memanggil API Gateway dan menyimpan skor.

Contoh Phaser.js:

function saveScore(gameId, userId, score) {
    var apiUrl = 'YOUR_API_GATEWAY_URL/scores';

    fetch(apiUrl, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            game_id: gameId,
            user_id: userId,
            score: score
        })
    })
    .then(response => response.json())
    .then(data => {
        console.log('Score saved:', data);
    })
    .catch(error => {
        console.error('Error saving score:', error);
    });
}

Panggil fungsi `saveScore` setelah game selesai dengan parameter yang sesuai.

Contoh Pygame:

import requests
import json

def save_score(game_id, user_id, score):
    api_url = 'YOUR_API_GATEWAY_URL/scores'

    payload = {
        'game_id': game_id,
        'user_id': user_id,
        'score': score
    }

    headers = {'Content-type': 'application/json'}
    try:
        response = requests.post(api_url, data=json.dumps(payload), headers=headers)
        response.raise_for_status()  # Raise HTTPError for bad responses (4xx or 5xx)
        print("Score saved successfully!")
    except requests.exceptions.RequestException as e:
        print(f"Error saving score: {e}")

Panggil fungsi `save_score` setelah game selesai dengan parameter yang sesuai.

Dengan mengintegrasikan dengan DynamoDB dan AWS Lambda, kita telah menunjukkan bagaimana Amazon Q Developer CLI dapat digunakan untuk mengotomatiskan dan menyederhanakan interaksi dengan layanan AWS. Kita telah menggunakan perintah `lambda deploy` untuk menyebarkan fungsi Lambda kita.

5. Menggunakan Amazon Q Developer CLI untuk Otomatisasi

Sekarang, mari kita jelajahi bagaimana kita dapat menggunakan Amazon Q Developer CLI untuk mengotomatiskan tugas-tugas yang berbeda terkait dengan penyebaran dan manajemen aplikasi kita.

5.1 Penerapan Aplikasi ke AWS (Misalnya, Menggunakan AWS Lambda dan API Gateway)

Seperti yang kita lihat di bagian sebelumnya, kita dapat menggunakan perintah `amazon-q lambda deploy` untuk menyebarkan fungsi Lambda. Namun, Amazon Q Developer CLI juga menyediakan cara untuk mengelola dan menyebarkan API Gateway.

Misalnya, Anda dapat menggunakan perintah `amazon-q apigateway create` untuk membuat API Gateway.

amazon-q apigateway create --name my-game-api --stage prod

Anda kemudian dapat menggunakan perintah `amazon-q apigateway integrate` untuk mengintegrasikan API Gateway dengan fungsi Lambda Anda.

amazon-q apigateway integrate --api-name my-game-api --resource scores --method POST --lambda-function save_score

Ini akan mengotomatiskan proses pembuatan API Gateway dan mengintegrasikannya dengan fungsi Lambda Anda.

5.2 Mengelola Sumber Daya AWS

Amazon Q Developer CLI menyediakan cara untuk mengelola berbagai sumber daya AWS. Misalnya, Anda dapat menggunakan perintah `amazon-q s3` untuk mengelola bucket S3 Anda.

            Posted in Tech News