Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Menggunakan CI/CD sistem dan jaringan pipa untuk digunakan AWS SAM AWS SAM membantu organisasi membuat saluran pipa untuk CI/CD sistem pilihan mereka, sehingga mereka dapat menyadari manfaat CI/CD dengan sedikit usaha, seperti mempercepat frekuensi penyebaran, mempersingkat lead time untuk perubahan, dan mengurangi kesalahan penerapan. AWS SAM menyederhanakan CI/CD tugas untuk aplikasi tanpa server dengan bantuan membangun gambar kontainer. Gambar yang AWS SAM disediakan menyertakan AWS SAMCLI dan membangun alat untuk sejumlah AWS Lambda runtime yang didukung. Ini membuatnya lebih mudah untuk membangun dan mengemas aplikasi tanpa server menggunakan file. AWS SAMCLI Gambar-gambar ini juga mengurangi kebutuhan tim untuk membuat dan mengelola gambar mereka sendiri untuk CI/CD sistem. Untuk informasi selengkapnya tentang AWS SAM membangun image container, lihat[Repositori gambar untuk AWS SAM](serverless-image-repositories.md). Beberapa CI/CD sistem mendukung AWS SAM membangun gambar kontainer. CI/CD Sistem mana yang harus Anda gunakan tergantung pada beberapa faktor. Hal ini termasuk apakah aplikasi Anda menggunakan satu atau beberapa waktu aktif, atau apakah Anda ingin membangun aplikasi Anda dalam citra kontainer atau langsung pada mesin host, baik mesin virtual (VM) atau host bare metal. AWS SAM juga menyediakan satu set template pipeline default untuk beberapa CI/CD sistem yang merangkum praktik terbaik AWS penerapan. Template pipeline default ini menggunakan format konfigurasi JSON/YAML pipeline standar, dan praktik terbaik bawaan membantu melakukan penerapan multi-akun dan multi-wilayah, serta memverifikasi bahwa pipeline tidak dapat membuat perubahan infrastruktur yang tidak diinginkan. Anda memiliki dua opsi utama AWS SAM untuk menggunakan aplikasi tanpa server: 1) Ubah konfigurasi pipeline yang ada untuk menggunakan AWS SAMCLI perintah, atau 2) Buat contoh konfigurasi CI/CD pipeline yang dapat Anda gunakan sebagai titik awal untuk aplikasi Anda sendiri. **Topics** + [Apa itu pipa?](#deploying-whatis-pipeline) + [Cara AWS SAM mengunggah file lokal saat penerapan](deploy-upload-local-files.md) + [Hasilkan CI/CD pipa starter dengan AWS SAM](serverless-generating-example-ci-cd.md) + [Cara menyesuaikan saluran pipa starter dengan AWS SAM](serverless-customizing-starter-pipelines.md) + [Otomatiskan penerapan aplikasi Anda AWS SAM](serverless-deploying-modify-pipeline.md) + [Cara menggunakan otentikasi OIDC dengan pipeline AWS SAM](deploying-with-oidc.md) ## Apa itu pipa? Pipeline adalah urutan otomatis langkah-langkah yang dilakukan untuk merilis versi baru dari aplikasi. [Dengan AWS SAM, Anda dapat menggunakan banyak CI/CD sistem umum untuk menyebarkan aplikasi Anda, termasuk, [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), dan Actions. GitHub](https://github.com/features/actions) Template pipeline mencakup praktik terbaik AWS penerapan untuk membantu penerapan multi-akun dan Multi-wilayah. AWS lingkungan seperti dev dan produksi biasanya ada di AWS akun yang berbeda. Hal ini memungkinkan tim pengembangan untuk mengonfigurasi pipeline penerapan yang aman, tanpa membuat perubahan infrastruktur yang tidak diinginkan. Anda juga dapat menyediakan template pipeline kustom Anda sendiri untuk membantu menstandarisasi pipeline di seluruh tim pengembangan. # Cara AWS SAM mengunggah file lokal saat penerapan Saat Anda menerapkan aplikasi ke AWS Cloud, AWS CloudFormation mengharuskan file lokal Anda diunggah terlebih dahulu ke AWS layanan yang dapat diakses, seperti Amazon Simple Storage Service (Amazon S3). Ini termasuk file lokal referensi AWS SAM template Anda. Untuk memenuhi persyaratan ini, AWS SAMCLI lakukan hal berikut ketika Anda menggunakan `sam package` perintah `sam deploy` or: 1. Secara otomatis mengunggah file lokal Anda ke AWS layanan yang dapat diakses. 1. Secara otomatis memperbarui template aplikasi Anda untuk mereferensikan jalur file baru. **Topics** + [Demo: Gunakan kode fungsi AWS SAMCLI untuk mengunggah Lambda](#deploy-upload-local-files-demo) + [Kasus penggunaan yang didukung](#deploy-upload-local-files-use) + [Pelajari selengkapnya](#deploy-upload-local-files-learn) ## Demo: Gunakan kode fungsi AWS SAMCLI untuk mengunggah Lambda Dalam demo ini, kami menginisialisasi contoh aplikasi Hello World menggunakan jenis paket.zip untuk fungsi Lambda kami. Kami menggunakan AWS SAMCLI untuk secara otomatis mengunggah kode fungsi Lambda kami ke Amazon S3 dan mereferensikan jalur barunya di templat aplikasi kami. Pertama, kami menjalankan `sam init` untuk menginisialisasi aplikasi Hello World kami. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: y Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: demo ----------------------- Generating application: ----------------------- Name: demo Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: demo/samconfig.toml ... ``` Kode fungsi Lambda kami diatur dalam `hello_world` subdirektori proyek kami. ``` demo ├── README.md ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── template.yaml └── tests ``` Dalam AWS SAM template kami, kami mereferensikan jalur lokal ke kode fungsi Lambda kami menggunakan properti. `CodeUri` ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.9 ... ``` Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami dan mempersiapkan penerapan. ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../demo/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml ... ``` Selanjutnya, kami menjalankan `sam deploy --guided` untuk menyebarkan aplikasi kami. ``` $ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [demo]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: n #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Saved arguments to config file Running 'sam deploy' for future deployments will use the parameters saved above. The above parameters can be changed by modifying samconfig.toml Learn more about samconfig.toml syntax at https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : demo Region : us-west-2 Confirm changeset : False Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== ... Waiting for changeset to be created.. CloudFormation stack changeset ------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement ------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A oWorldPermissionProd n + Add HelloWorldFunctionRole AWS::IAM::Role N/A ... ------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f 2023-04-07 12:24:58 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 5.0 seconds) ------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason ------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated ... ------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ------------------------------------------------------------------------------------------------- Outputs ------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:demo- HelloWorldFunction-G14inKTmSQvK ------------------------------------------------------------------------------------------------- Successfully created/updated stack - demo in us-west-2 ``` Selama penerapan, AWS SAMCLI secara otomatis mengunggah kode fungsi Lambda kami ke Amazon S3 dan memperbarui template kami. Template kami yang dimodifikasi di CloudFormation konsol mencerminkan jalur bucket Amazon S3. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8 Handler: app.lambda_handler ... ``` ## Kasus penggunaan yang didukung Secara otomatis AWS SAMCLI dapat memfasilitasi proses ini untuk sejumlah jenis file, jenis CloudFormation sumber daya, dan CloudFormation makro. ### Jenis berkas File dan Docker gambar aplikasi didukung. ### CloudFormation jenis sumber daya Berikut ini adalah daftar jenis sumber daya yang didukung dan propertinya: | Sumber daya | Sifat-sifat | | --- | --- | | AWS::ApiGateway::RestApi | BodyS3Location | | AWS::ApiGatewayV2::Api | BodyS3Location | | AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::AppSync::GraphQLSchema | DefinitionS3Location | | AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::CloudFormation::ModuleVersion | ModulePackage | | AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage | | AWS::ECR::Repository | RepositoryName | | AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle | | AWS::Glue::Job | Command.ScriptLocation | | AWS::Lambda::Function | `Code` `Code.ImageUri` | | AWS::Lambda::LayerVersion | Content | | AWS::Serverless::Api | DefinitionUri | | AWS::Serverless::Function | `CodeUri` `ImageUri` | | AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` | | AWS::Serverless::HttpApi | DefinitionUri | | AWS::Serverless::LayerVersion | ContentUri | | AWS::Serverless::StateMachine | DefinitionUri | | AWS::StepFunctions::StateMachine | DefinitionS3Location | ### CloudFormation makro File yang direferensikan menggunakan makro `AWS::Include` transformasi didukung. ## Pelajari selengkapnya Untuk mempelajari lebih lanjut tentang `AWS::Include` transformasi, lihat [ AWS::Include transformasi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) di *Panduan AWS CloudFormation Pengguna*. Untuk melihat contoh penggunaan `AWS::Include` transformasi dalam AWS SAM template, lihat pola [API Gateway API API ke SQS](https://serverlessland.com/patterns/apigw-sqs) di *Serverless* Land. # Hasilkan CI/CD pipa starter dengan AWS SAM Saat Anda siap mengotomatiskan penerapan, Anda dapat menggunakan salah AWS SAM satu templat pipeline pemula untuk menghasilkan pipeline penerapan untuk CI/CD sistem yang Anda pilih untuk digunakan. Pipeline penerapan Anda adalah apa yang Anda konfigurasikan dan gunakan untuk mengotomatiskan penerapan aplikasi tanpa server Anda. Template pipeline pemula sudah dikonfigurasi sebelumnya untuk membantu Anda menyiapkan pipeline penerapan dengan cepat untuk aplikasi tanpa server Anda. Dengan template pipeline starter, Anda dapat menghasilkan saluran pipa dalam hitungan menit menggunakan [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md) perintah. Template pipeline starter menggunakan JSON/YAML sintaks CI/CD sistem yang sudah dikenal, dan menggabungkan praktik terbaik seperti mengelola artefak di beberapa akun dan wilayah, dan menggunakan jumlah izin minimum yang diperlukan untuk menerapkan aplikasi. [https://github.com/features/actions](https://github.com/features/actions) Berikut adalah tugas tingkat tinggi yang perlu Anda lakukan untuk menghasilkan konfigurasi alur awal: 1. **Buat sumber daya infrastruktur** — Pipeline Anda memerlukan AWS sumber daya tertentu, misalnya pengguna IAM dan peran dengan izin yang diperlukan, bucket Amazon S3, dan secara opsional repositori Amazon ECR. 1. **Hubungkan repositori Git Anda dengan CI/CD sistem Anda — CI/CD Sistem** Anda perlu mengetahui repositori Git mana yang akan memicu pipeline untuk dijalankan. Perhatikan bahwa langkah ini mungkin tidak diperlukan, tergantung pada kombinasi repositori Git dan CI/CD sistem yang Anda gunakan. 1. **Hasilkan konfigurasi alur Anda** – Langkah ini menghasilkan konfigurasi alur awal yang mencakup dua tahap deployment. 1. **Komit konfigurasi pipeline Anda ke repositori Git Anda** — Langkah ini diperlukan untuk memastikan CI/CD sistem Anda mengetahui konfigurasi pipeline Anda, dan akan berjalan ketika perubahan dilakukan. Setelah Anda membuat konfigurasi alur awal dan melakukannya ke repositori Git Anda, setiap kali seseorang melakukan perubahan kode ke repositori tersebut, alur Anda akan terpicu untuk berjalan secara otomatis. Urutan langkah-langkah ini, dan detail setiap langkah, bervariasi berdasarkan sistem CI/CD Anda: + Jika Anda menggunakan AWS CodePipeline, lihat[Menghasilkan pipa starter untuk AWS CodePipeline in AWS SAM](serverless-generating-example-ci-cd-codepipeline.md). + Jika Anda menggunakan Jenkins, GitLab CI/CD, GitHub Actions, atau Bitbucket Pipelines, lihat. [Gunakan AWS SAM untuk menghasilkan pipa starter untuk Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub](serverless-generating-example-ci-cd-others.md) # Menghasilkan pipa starter untuk AWS CodePipeline in AWS SAM Untuk menghasilkan konfigurasi pipeline starter AWS CodePipeline, lakukan tugas-tugas berikut dalam urutan ini: 1. Buat sumber daya infrastruktur 1. Hasilkan konfigurasi alur 1. Lakukan konfigurasi alur Anda ke Git 1. Hubungkan repositori Git Anda dengan sistem Anda CI/CD **catatan** Prosedur berikut menggunakan dua AWS SAMCLI perintah, `sam pipeline bootstrap` dan`sam pipeline init`. Alasan ada dua perintah adalah untuk menangani kasus penggunaan di mana administrator (yaitu, pengguna yang memerlukan izin untuk mengatur AWS sumber daya infrastruktur seperti pengguna dan peran IAM) memiliki lebih banyak izin daripada pengembang (yaitu, pengguna yang hanya memerlukan izin untuk mengatur saluran pipa individu, tetapi bukan sumber daya infrastruktur AWS yang diperlukan). ## Langkah 1: Buat sumber daya infrastruktur Saluran pipa yang menggunakan AWS SAM memerlukan AWS sumber daya tertentu, seperti pengguna IAM dan peran dengan izin yang diperlukan, bucket Amazon S3, dan secara opsional repositori Amazon ECR. Anda harus memiliki satu set sumber daya infrastruktur untuk setiap tahap deployment alur. Anda dapat menjalankan perintah berikut guna membantu penyiapan ini: ``` sam pipeline bootstrap ``` **catatan** Jalankan perintah sebelumnya untuk setiap tahap penerapan pipeline Anda. ## Langkah 2: Hasilkan konfigurasi alur Untuk menghasilkan konfigurasi alur, jalankan perintah berikut: ``` sam pipeline init ``` ## Langkah 3: Lakukan konfigurasi alur Anda ke repositori Git Langkah ini diperlukan untuk memastikan CI/CD sistem Anda mengetahui konfigurasi pipeline Anda, dan akan berjalan saat perubahan dilakukan. ## Langkah 4: Hubungkan repositori Git Anda dengan sistem Anda CI/CD Untuk AWS CodePipeline Anda sekarang dapat membuat koneksi dengan menjalankan perintah berikut: ``` sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region ``` Jika Anda menggunakan GitHub atau Bitbucket, setelah menjalankan **sam deploy** perintah sebelumnya, selesaikan koneksi dengan mengikuti langkah-langkah di bawah **Untuk menyelesaikan koneksi yang ditemukan pada topik Perbarui koneksi** [yang tertunda](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) di *panduan pengguna konsol Alat Pengembang*. Selain itu, simpan salinan `CodeStarConnectionArn` dari output **sam deploy** perintah, karena Anda akan membutuhkannya jika Anda ingin menggunakan AWS CodePipeline dengan cabang lain selain`main`. ## Mengonfigurasi cabang-cabang lain Secara default, AWS CodePipeline gunakan `main` cabang dengan AWS SAM. Jika ingin menggunakan cabang selain `main`, Anda harus menjalankan kembali perintah **sam deploy**. Perhatikan bahwa bergantung pada repositori Git mana yang digunakan, Anda mungkin juga perlu menyediakan `CodeStarConnectionArn`: ``` # For GitHub and Bitbucket sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn=" # For AWS CodeCommit sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch=" ``` ## Pelajari selengkapnya *Untuk contoh langsung menyiapkan CI/CD pipeline, lihat [CI/CD dengan AWS CodePipeline](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) di The Complete Workshop. AWS SAM * # Gunakan AWS SAM untuk menghasilkan pipa starter untuk Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub Untuk menghasilkan konfigurasi pipeline starter untuk Jenkins, GitLab CI/CD, GitHub Actions, atau Bitbucket Pipelines, lakukan tugas-tugas berikut dalam urutan ini: 1. Buat sumber daya infrastruktur 1. Hubungkan repositori Git Anda dengan sistem Anda CI/CD 1. Buat objek kredensial 1. Hasilkan konfigurasi alur 1. Lakukan konfigurasi alur Anda ke repositori Git **catatan** Prosedur berikut menggunakan dua AWS SAMCLI perintah, `sam pipeline bootstrap` dan`sam pipeline init`. Alasan ada dua perintah adalah untuk menangani kasus penggunaan di mana administrator (yaitu, pengguna yang memerlukan izin untuk mengatur AWS sumber daya infrastruktur seperti pengguna dan peran IAM) memiliki lebih banyak izin daripada pengembang (yaitu, pengguna yang hanya memerlukan izin untuk mengatur saluran pipa individu, tetapi bukan sumber daya infrastruktur AWS yang diperlukan). ## Langkah 1: Buat sumber daya infrastruktur Saluran pipa yang menggunakan AWS SAM memerlukan AWS sumber daya tertentu, seperti pengguna IAM dan peran dengan izin yang diperlukan, bucket Amazon S3, dan secara opsional repositori Amazon ECR. Anda harus memiliki satu set sumber daya infrastruktur untuk setiap tahap deployment alur. Anda dapat menjalankan perintah berikut guna membantu penyiapan ini: ``` sam pipeline bootstrap ``` **catatan** Jalankan perintah sebelumnya untuk setiap tahap penerapan pipeline Anda. Anda harus menangkap AWS kredensil (id kunci dan kunci rahasia) untuk pengguna pipeline untuk setiap tahap penerapan pipeline Anda, karena diperlukan untuk langkah selanjutnya. ## Langkah 2: Hubungkan repositori Git Anda dengan sistem Anda CI/CD Menghubungkan repositori Git Anda ke CI/CD sistem Anda diperlukan agar CI/CD sistem dapat mengakses kode sumber aplikasi Anda untuk build dan deployment. **catatan** Anda dapat melewati langkah ini jika menggunakan salah satu kombinasi berikut, karena koneksi dibuat untuk Anda secara otomatis: GitHub Tindakan dengan GitHub repositori GitLab CI/CD dengan repositori GitLab Bitbucket Pipelines dengan repositori Bitbucket Untuk menghubungkan repositori Git Anda dengan CI/CD sistem Anda, lakukan salah satu hal berikut: + Jika Anda menggunakan Jenkins, lihat [dokumentasi Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/) untuk “Menambahkan sumber cabang.” + Jika Anda menggunakan GitLab CI/CD dan repositori Git selain GitLab, lihat [GitLabdokumentasi](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) untuk “menghubungkan repositori eksternal.” ## Langkah 3: Buat objek kredensial Setiap CI/CD sistem memiliki caranya sendiri untuk mengelola kredensialnya yang diperlukan agar CI/CD sistem dapat mengakses repositori Git Anda. Untuk membuat objek kredensial yang diperlukan, lakukan salah satu hal berikut: + Jika Anda menggunakan Jenkins, buat satu "kredensial" yang menyimpan id kunci dan kunci rahasia. Ikuti instruksi di blog [Membangun Alur Jenkins dengan AWS SAM](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), di bagian **Konfigurasikan Jenkins**. Anda akan membutuhkan “id Kredensial” untuk langkah berikutnya. + Jika Anda menggunakan GitLab CI/CD, buat dua “variabel yang dilindungi”, satu untuk masing-masing id kunci dan kunci rahasia. Ikuti petunjuk dalam [GitLab dokumentasi](https://docs.gitlab.com/ee/ci/variables/) - Anda akan memerlukan dua “kunci variabel” untuk langkah berikutnya. + Jika Anda menggunakan GitHub Actions, buat dua “rahasia terenkripsi”, satu untuk masing-masing kunci dan kunci rahasia. Ikuti instruksi dalam [GitHubdokumentasi](https://docs.github.com/en/actions/reference/encrypted-secrets) - Anda akan memerlukan dua “nama rahasia” untuk langkah selanjutnya. + Jika Anda menggunakan Bitbucket Pipelines, buat dua “variabel aman”, satu untuk masing-masing id kunci dan kunci rahasia. Ikuti instruksi dalam [Variabel dan rahasia](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets) - Anda akan memerlukan dua “nama rahasia” untuk langkah berikutnya. ## Langkah 4: Hasilkan konfigurasi alur Untuk menghasilkan konfigurasi alur, jalankan perintah berikut. Anda harus memasukkan objek kredensial yang dibuat pada langkah sebelumnya: ``` sam pipeline init ``` ## Langkah 5: Lakukan konfigurasi alur Anda ke repositori Git Langkah ini diperlukan untuk memastikan CI/CD sistem Anda mengetahui konfigurasi pipeline Anda, dan akan berjalan saat perubahan dilakukan. ## Pelajari selengkapnya *Untuk contoh langsung menyiapkan CI/CD pipeline menggunakan, lihat [CI/CD dengan GitHub](https://s12d.com/sam-ws-en-gh) di GitHub Actions The Complete Workshop. AWS SAM * # Cara menyesuaikan saluran pipa starter dengan AWS SAM Sebagai CI/CD administrator, Anda mungkin ingin menyesuaikan template pipeline pemula, dan petunjuk terpandu terkait, yang dapat digunakan pengembang di organisasi Anda untuk membuat konfigurasi pipeline. AWS SAMCLIMenggunakan template Cookiecutter saat membuat template pemula. Untuk detail tentang template pemotong kue, [Cookiecutter](https://cookiecutter.readthedocs.io/en/latest/README.html). Anda juga dapat menyesuaikan prompt yang AWS SAMCLI ditampilkan kepada pengguna saat membuat konfigurasi pipeline menggunakan perintah. `sam pipeline init` Untuk menyesuaikan permintaan pengguna, lakukan hal berikut: 1. **Buat `questions.json` file** — `questions.json` File harus berada di root respositori proyek. Ini adalah direktori yang sama dengan `cookiecutter.json` file. Untuk melihat skema `questions.json` file, lihat [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). Untuk melihat `questions.json` file contoh, lihat [questions.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json). 1. **Peta kunci pertanyaan dengan nama cookiecutter** - Setiap objek dalam `questions.json` file membutuhkan kunci yang cocok dengan nama dalam template cookiecutter. Pencocokan kunci ini adalah bagaimana pengguna AWS SAMCLI memetakan tanggapan meminta ke template pemotong cookie. Untuk melihat contoh pencocokan kunci ini, lihat [Contoh file](#serverless-customizing-starter-pipelines-example-files) bagian nanti dalam topik ini. 1. **Buat `metadata.json` file** — Deklarasikan jumlah tahapan yang akan dimiliki pipeline dalam file. `metadata.json` Jumlah tahapan menginstruksikan `sam pipeline init` perintah berapa banyak tahapan untuk meminta informasi tentang, atau dalam kasus `--bootstrap` opsi, berapa banyak tahapan untuk membuat sumber daya infrastruktur untuk. Untuk melihat `metadata.json` file contoh yang mendeklarasikan pipeline dengan dua tahap, lihat [metadata.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json). ## Contoh proyek Berikut adalah contoh proyek, yang masing-masing menyertakan template Cookiecutter, `questions.json` file, dan file: `metadata.json` + Contoh Jenkins: Template pipa [Jenkins dua tahap](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template) + CodePipeline contoh: [Template CodePipeline pipa dua tahap](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template) ## Contoh file Kumpulan file berikut menunjukkan bagaimana pertanyaan dalam `questions.json` file dikaitkan dengan entri dalam file template Cookiecutter. Perhatikan bahwa contoh ini adalah cuplikan file, bukan file lengkap. Untuk melihat contoh file lengkap, lihat [Contoh proyek](#serverless-customizing-starter-pipelines-example-projects) bagian sebelumnya dalam topik ini. Contoh **`questions.json`**: ``` { "questions": [{ "key": "intro", "question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n", "kind": "info" }, { "key": "pipeline_user_jenkins_credential_id", "question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?", "isRequired": true }, { "key": "sam_template", "question": "What is the template file path?", "default": "template.yaml" }, { ... ``` Contoh **`cookiecutter.json`**: ``` { "outputDir": "aws-sam-pipeline", "pipeline_user_jenkins_credential_id": "", "sam_template": "", ... ``` Contoh **`Jenkinsfile`**: ``` pipeline { agent any environment { PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}' SAM_TEMPLATE = '{{cookiecutter.sam_template}}' ... ``` # Otomatiskan penerapan aplikasi Anda AWS SAM Dalam AWS SAM, cara Anda mengotomatiskan penerapan AWS SAM aplikasi Anda bervariasi tergantung pada CI/CD sistem yang Anda gunakan. Untuk alasan ini, contoh di bagian ini menunjukkan kepada Anda cara mengonfigurasi berbagai CI/CD sistem untuk mengotomatiskan pembuatan aplikasi tanpa server dalam image kontainer AWS SAM build. Gambar kontainer build ini memudahkan pembuatan dan paket aplikasi tanpa server menggunakan file. AWS SAMCLI Prosedur untuk CI/CD pipeline yang ada untuk menyebarkan aplikasi tanpa server yang AWS SAM digunakan sedikit berbeda tergantung pada CI/CD sistem yang Anda gunakan. Topik berikut memberikan contoh untuk mengonfigurasi CI/CD sistem Anda untuk membangun aplikasi tanpa server dalam image container AWS SAM build: **Topics** + [Menggunakan AWS CodePipeline untuk menyebarkan dengan AWS SAM](deploying-using-codepipeline.md) + [Menggunakan Bitbucket Pipelines untuk menerapkan dengan AWS SAM](deploying-using-bitbucket.md) + [Menggunakan Jenkins untuk menyebarkan AWS SAM](deploying-using-jenkins.md) + [Menggunakan GitLab CI/CD untuk menyebarkan dengan AWS SAM](deploying-using-gitlab.md) + [Menggunakan GitHub Tindakan untuk menyebarkan dengan AWS SAM](deploying-using-github.md) # Menggunakan AWS CodePipeline untuk menyebarkan dengan AWS SAM Untuk mengonfigurasi [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)pipeline agar mengotomatiskan pembuatan dan penerapan AWS SAM aplikasi, CloudFormation template dan `buildspec.yml` file harus berisi baris yang melakukan hal berikut: 1. Referensikan citra kontainer build dengan waktu aktif yang diperlukan dari citra yang tersedia. Contoh berikut menggunakan citra kontainer build `public.ecr.aws/sam/build-nodejs20.x`. 1. Konfigurasikan tahapan pipeline untuk menjalankan AWS SAM perintah command line interface (CLI) yang diperlukan. Contoh berikut menjalankan dua AWS SAMCLI perintah: **sam build** dan **sam deploy** (dengan opsi yang diperlukan). Contoh ini mengasumsikan bahwa Anda telah mendeklarasikan semua fungsi dan lapisan dalam file AWS SAM template Anda dengan`runtime: nodejs20.x`. **CloudFormation cuplikan templat:** ``` CodeBuildProject: Type: AWS::CodeBuild::Project Properties: Environment: ComputeType: BUILD_GENERAL1_SMALL Image: public.ecr.aws/sam/build-nodejs20.x Type: LINUX_CONTAINER ... ``` **`buildspec.yml`cuplikan:** ``` version: 0.2 phases: build: commands: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Untuk daftar citra kontainer build Amazon Elastic Container Registry (Amazon ECR) yang tersedia untuk waktu aktif yang berbeda, lihat [Repositori gambar untuk AWS SAM](serverless-image-repositories.md). # Menggunakan Bitbucket Pipelines untuk menerapkan dengan AWS SAM Untuk mengonfigurasi [Bitbucket Pipeline](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) untuk mengotomatiskan pembuatan dan penerapan AWS SAM aplikasi Anda, `bitbucket-pipelines.yml` file Anda harus berisi baris yang melakukan hal berikut: 1. Referensikan citra kontainer build dengan waktu aktif yang diperlukan dari citra yang tersedia. Contoh berikut menggunakan citra kontainer build `public.ecr.aws/sam/build-nodejs20.x`. 1. Konfigurasikan tahapan pipeline untuk menjalankan AWS SAM perintah command line interface (CLI) yang diperlukan. Contoh berikut menjalankan dua AWS SAMCLI perintah: **sam build** dan **sam deploy** (dengan opsi yang diperlukan). Contoh ini mengasumsikan bahwa Anda telah mendeklarasikan semua fungsi dan lapisan dalam file AWS SAM template Anda dengan`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x pipelines: branches: main: # branch name - step: name: Build and Package script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Untuk daftar citra kontainer build Amazon Elastic Container Registry (Amazon ECR) yang tersedia untuk waktu aktif yang berbeda, lihat [Repositori gambar untuk AWS SAM](serverless-image-repositories.md). # Menggunakan Jenkins untuk menyebarkan AWS SAM Untuk mengonfigurasi pipeline [Jenkins](https://www.jenkins.io/) untuk mengotomatiskan pembuatan dan penerapan AWS SAM aplikasi Anda, Anda `Jenkinsfile` harus berisi baris yang melakukan hal berikut: 1. Referensikan citra kontainer build dengan waktu aktif yang diperlukan dari citra yang tersedia. Contoh berikut menggunakan citra kontainer build `public.ecr.aws/sam/build-nodejs20.x`. 1. Konfigurasikan tahapan pipeline untuk menjalankan AWS SAM perintah command line interface (CLI) yang diperlukan. Contoh berikut menjalankan dua AWS SAMCLI perintah: **sam build** dan **sam deploy** (dengan opsi yang diperlukan). Contoh ini mengasumsikan bahwa Anda telah mendeklarasikan semua fungsi dan lapisan dalam file AWS SAM template Anda dengan`runtime: nodejs20.x`. ``` pipeline { agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } } stages { stage('build') { steps { sh 'sam build' sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset' } } } } ``` Untuk daftar citra kontainer build Amazon Elastic Container Registry (Amazon ECR) yang tersedia untuk waktu aktif yang berbeda, lihat [Repositori gambar untuk AWS SAM](serverless-image-repositories.md). # Menggunakan GitLab CI/CD untuk menyebarkan dengan AWS SAM Untuk mengonfigurasi [GitLab](https://about.gitlab.com)pipeline agar mengotomatiskan pembuatan dan penerapan AWS SAM aplikasi, `gitlab-ci.yml` file harus berisi baris yang melakukan hal berikut: 1. Referensikan citra kontainer build dengan waktu aktif yang diperlukan dari citra yang tersedia. Contoh berikut menggunakan citra kontainer build `public.ecr.aws/sam/build-nodejs20.x`. 1. Konfigurasikan tahapan pipeline untuk menjalankan AWS SAM perintah command line interface (CLI) yang diperlukan. Contoh berikut menjalankan dua AWS SAMCLI perintah: **sam build** dan **sam deploy** (dengan opsi yang diperlukan). Contoh ini mengasumsikan bahwa Anda telah mendeklarasikan semua fungsi dan lapisan dalam file AWS SAM template Anda dengan`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x deploy: script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Untuk daftar citra kontainer build Amazon Elastic Container Registry (Amazon ECR) yang tersedia untuk waktu aktif yang berbeda, lihat [Repositori gambar untuk AWS SAM](serverless-image-repositories.md). # Menggunakan GitHub Tindakan untuk menyebarkan dengan AWS SAM Untuk mengonfigurasi [GitHub](https://github.com/)pipeline untuk mengotomatiskan pembuatan dan penerapan AWS SAM aplikasi, Anda harus terlebih dahulu menginstal antarmuka baris AWS SAM perintah (CLI) di host Anda. Anda dapat menggunakan [GitHub Tindakan](https://github.com/features/actions) dalam GitHub alur kerja untuk membantu penyiapan ini. Contoh GitHub alur kerja berikut menyiapkan host Ubuntu menggunakan serangkaian GitHub Tindakan, lalu menjalankan AWS SAMCLI perintah untuk membangun dan menyebarkan aplikasi AWS SAM : ``` on: push: branches: - main jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v3 - uses: aws-actions/setup-sam@v2 - uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-2 - run: sam build --use-container - run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Untuk daftar citra kontainer build Amazon Elastic Container Registry (Amazon ECR) yang tersedia untuk waktu aktif yang berbeda, lihat [Repositori gambar untuk AWS SAM](serverless-image-repositories.md). # Cara menggunakan otentikasi OIDC dengan pipeline AWS SAM AWS Serverless Application Model (AWS SAM) mendukung otentikasi pengguna OpenID Connect (OIDC) untuk Bitbucket, GitHub Actions, dan integrasi GitLab berkelanjutan dan pengiriman berkelanjutan (akun CI/CD) platforms. With this support, you can use authorized CI/CD pengguna dari salah satu platform ini untuk mengelola pipeline aplikasi tanpa server Anda. Jika tidak, Anda perlu membuat dan mengelola beberapa AWS Identity and Access Management (IAM) pengguna untuk mengontrol akses ke AWS SAM saluran pipa. ## Siapkan OIDC dengan pipa AWS SAM Selama proses `sam pipeline bootstrap` konfigurasi, lakukan hal berikut untuk mengatur OIDC dengan pipeline Anda AWS SAM . 1. Saat diminta untuk memilih penyedia identitas, pilih **OIDC**. 1. Selanjutnya, pilih penyedia OIDC yang didukung. 1. Masukkan URL penyedia OIDC, dimulai dengan. **https://** **catatan** AWS SAM referensi URL ini ketika menghasilkan jenis `AWS::IAM::OIDCProvider` sumber daya. 1. Selanjutnya, ikuti petunjuknya dan masukkan informasi CI/CD platform yang diperlukan untuk mengakses platform yang dipilih. Detail ini bervariasi menurut platform dan dapat mencakup: + ID klien OIDC. + Nama repositori kode atau pengidentifikasi unik universal (UUID). + Nama grup atau organisasi yang terkait dengan repositori. + GitHub organisasi tempat repositori kode milik. + GitHub nama repositori. + Cabang tempat penerapan akan terjadi. 1. AWS SAM menampilkan ringkasan konfigurasi OIDC yang dimasukkan. Masukkan nomor untuk pengaturan untuk mengeditnya, atau tekan Enter untuk melanjutkan. 1. Ketika diminta untuk mengkonfirmasi pembuatan sumber daya yang diperlukan untuk mendukung koneksi OIDC yang dimasukkan, tekan Y untuk melanjutkan. AWS SAM menghasilkan `AWS::IAM::OIDCProvider` AWS CloudFormation sumber daya dengan konfigurasi yang disediakan yang mengasumsikan peran eksekusi pipeline. Untuk mempelajari lebih lanjut tentang jenis CloudFormation sumber daya ini, lihat [AWS: :IAM:: OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) di *AWS CloudFormation Panduan Pengguna*. **catatan** Jika sumber daya penyedia identitas (iDP) sudah ada di sumber daya Anda Akun AWS, AWS SAM referensikan itu alih-alih membuat sumber daya baru. ## Contoh Berikut ini adalah contoh pengaturan OIDC dengan AWS SAM pipeline. ``` Select a permissions provider: 1 - IAM (default) 2 - OpenID Connect (OIDC) Choice (1, 2): 2 Select an OIDC provider: 1 - GitHub Actions 2 - GitLab 3 - Bitbucket Choice (1, 2, 3): 1 Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]: Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]: Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org Enter GitHub repository name: testing Enter the name of the branch that deployments will occur from [main]: [3] Reference application build resources Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []: Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []: Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []: Does your application contain any IMAGE type Lambda functions? [y/N]: [4] Summary Below is the summary of the answers: 1 - Account: 123456 2 - Stage configuration name: dev 3 - Region: us-east-1 4 - OIDC identity provider URL: https://token.actions.githubusercontent.com 5 - OIDC client ID: sts.amazonaws.com 6 - GitHub organization: my-org 7 - GitHub repository: testing 8 - Deployment branch: main 9 - Pipeline execution role: [to be created] 10 - CloudFormation execution role: [to be created] 11 - Artifacts bucket: [to be created] 12 - ECR image repository: [skipped] Press enter to confirm the values above, or select an item to edit the value: This will create the following required resources for the 'dev' configuration: - IAM OIDC Identity Provider - Pipeline execution role - CloudFormation execution role - Artifact bucket Should we proceed with the creation? [y/N]: ``` ## Pelajari selengkapnya Untuk informasi selengkapnya tentang penggunaan OIDC dengan AWS SAM pipeline, lihat. [sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md)