Since your code is already hosted on Github I would suggest using Github Actions. Start by creating a .github/workflows directory in the root of your project and create a new file that ends with the .yml extention.

Start with github actions, since you are already using github. Checkout https://docs.github.com/en/actions/learn-github-actions

I suggest you set up GIT action so there is a ready workflow based on technology.

Github works best with Github Actions due to obvious reasons. You should also explore AWS CodePipeline as well.

Github FTW... extremely customizable and has tons of tie in hooks that can make creating tests/scans/package/deployment VERY specific in the workflow. Dependencies can trigger pipelines in other repos as well to create chains. If you have an upgraded github account, you can also make use of github environments which allows variables per environment with gated release controls managed by teams (much like how it is/was in Azure DevOps).

Since you're using GitHub, GitHub Actions seems like a straightforward option. AWS officially provides several off-the-shelf actions for deploying various AWS workloads from GitHub Actions. You can also configure OIDC between GitHub and AWS that removes the need to manage things like AWS access keys for your CICD actions.

See GitHub Actions documentation for more information.

why not thinking about Github Actions ? in our company we manage repos on gitlab, so we decide to use Gitlab CI/CD, like that we manage a lot of thing in the same place (code, pipelines, registries ...).

I would strong suggest github action along with OIDC (some folks said it), and you can use ECR to publish your images.

In this way, you can also introduce cache action and slack integration to improve devex.

I always find that I like Gitlab the most. It’s open source and you can host it yourself. That gives you a lot of freedom and privacy. I also think Gitlab has better issue management, etc. than GitHub.

Of course, if you want to use GitLab, they have guides on how to do just about everything, just like GitHub.

AWS is fine, but I personally like Linode, Vultr and Oracle Cloud because they’re less about the BS and more about the raw compute and network performance.

Just my two cents.

The most reliable and convenient way to set up CI/CD for your Node.js and PHP Laravel applications hosted on GitHub and deployed to AWS would be to use GitHub Actions. GitHub Actions offers seamless integration with your existing GitHub repositories, allowing for automated workflows for continuous integration and continuous deployment directly from your GitHub repository.
read : https://docs.github.com/en/actions

I recommend using GitHub Actions. While I've been a long-time user of Jenkins, and it continues to be my company's choice, GitHub Actions stands out, especially if your projects are hosted on GitHub, as others have also suggested. Transitioning my personal projects' CI/CD pipelines from a self-hosted, internal Jenkins to GitHub Actions' workflow YAMLs was surprisingly easy.

GitHub Actions is free for public repositories. Moreover, even the free GitHub plan provides a substantial allowance (currently 2000 minutes), allowing you to thoroughly assess whether it meets your requirements or not.

if you are using AWS maybe can use their CICD tools, so you would have to move from github to codecommit.

Other way would be build your own CICD with Jenkins, Github Actions or other tools with plugins to connect with AWS.

Most CICD tools have plugins to cloud applications e.g. AWS etc. Having used Jenkins and Bamboo, my preference is for self-hosted Jenkins if you had to choose between the two. It seems to be the most common choice these days.

However considering that you are using GitHub for code-commit it might be easier to use GitHub actions. So you will only have to deal with GitHub and AWS.

Recently I worked with GitHub actions I hope it suits best! IMO

it depends in many aspects, but for a simple answer i recommend github action like the others dude answered yet, for a totally cicd pipeline.

For a more tecnical answer or for production ecosystem, i prefer separate environments, CI and CD with differents tools. CI with github action or Jenkins for example, then a container registry (ECR from AWS) and for CD argoCD is a good option for deploy your apps.

My choice is usually 2 (used both)->
1. GitHub Actions
2. CircleCI

Out of the box GitHub Actions offers 2,000 minutes per month, CircleCI offers up to 6,000 build minutes per month. CircleCI seems faster but GitHub Action offers more flexibility in terms of running workflows for certain events, which makes it more powerful.

You can see the pricing plan for [GHA](https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions) & [CCI](https://circleci.com/pricing/).

Its personal choice, I have worked on jenkins, bitbucket, aws codepipeline, github actions gitlab ci.

I would choose the one native to git repository that the developers are using to code. So, that they easily see the errors in their repository and you do not need to manage another access rights to allow them access and view pipeline errors.

Hence, in your use case I would choose Github actions(where your code resides).

With your codebase in github it makes sense to me if you were to use GH actions, and I think you can leverage CodePipeline and CodeBuild too, since you are on AWS.

I think the most reliable way is to setup a CI/CD pipeline is to use gitAction because it supports both nodeJs and PHP larvel.

Code Commit + Code Build/Code deploy/CodePipeline : You might need some AWS knowledge to achive that, it also cost money.
Github action: Free, easy to setup. It's a bit limited.
Jenkins/CircleCI,... : These tools provide more ways to test/deploy your code. Jenkins is less reliable if you don't know what plugins to use. They also need a server to be able to work, thus increase the cost.

My org (~200 techs) has standardized on Github. The ecosystem of packaged actions is large, the pricing is just OK. It is also fairly developer friendly, and easy to maintain. Those last two points are of particular importance.

We have also set up the Philips Labs module as a way to run our own managed runners, mainly for CI jobs that require faster CPUs than those provided by Github. They are also cheaper, but this is a drop in the bucket.

AWS maintains a number of Github Actions, so unless you need something very specific, you should find everything you need, maintained by large tech companies.

Just be careful with the actions you use, and the security of it all, since a Github Action can be updated with malicious code without you noticing, if you refer to it by tag and not explicit SHA. It's mostly safe of course, but we had a large breach (not from Github!), and are especially paranoid on everything now.

As my code is in GitHub, I always use GitHub-actions. This also ensure the CICD (Workflow files) code also is on repository and versioned. Only problem is during deploying to on prem repository and on prem machines (which has Kubernetes), which can be saved by setting up on prem git runners

Well. In my personal opinion, it would be better to choose where you have your centralized version control system. But its not limited to it.

If you have your code in,

1. github, then Github Actions.

2. Bitbucket, then Bitbucket Pipelines.

3. Azure Devops.

4. AWS Code deploy, then AWS Code Pipelines. etc..

Start using Github workflows to setup the CI/CD, that is greatly managed tool for the same. For this you should aware about yml extension and content to be written in that file to manage your pipeline and jobs.

You can use jenkins and gitlabs. I prefer gitlabs.

IMO

You need to GitHub Actions which does CI for you project.

In this CI I am considering Code checks, security checks, lint checks etc and packing it into zip ( for artifact creation) which moves this zip into s3 into AWS for audits.

Once it is checked into S3 you can use Codepipeline for CD. ( CodeBuild too if you want to run some processing before deploying). Each time it is uploaded to S3 it will trigger codepipeline. Codepipeline also allows you to add manual approval action which you can use to add to your slack using lambda which contains codepipeline console link, execution id and codebuild plan to see what will be deployed.

Hello
In the future you can consider this idea.
1:If it is a free tier for public repos do consider GitHub Actions as it offers unlimited minutes for public repos.
2:For private repos do consider CirclCi as it has a 3,000 minutes free tier while Github Actions has 2,000 minutes.

AWS has their own set of tools. These are:

• AWS codepipeline

• AWS codeploy

• AWS Codebuild

If you want to have everything except your git repo in AWS, go with the AWS Code* services, you can connect them with Github via CodeStar and then have fun with CodePipeline, CodeBuild and CodeDeploy.

They do what you would expect from CICD tools, sometimes really well, and most of the time you will realize how much convenience other tools established which you never valued...

If you want to have weekly challenges and some sleepless nights till your CICD is up and running, I definitely encourage you to give the AWS Code stack a try, otherwise go with GitHub action and be happy ;)

It's hard to beat GitHub. It saves a ton of time given the number of integrations for things that aren't necessisarily CICD but are helpful additions. For example, if you want to track CICD metrics in Datadog, there is currently no easier option than Github, with a significant extra effort to wire up non-Github alternatives.

If you use GitHub, it is better to use GitHub Action. But I used both GitHub Action and Jenkins, I prefer Jenkins for CI/CD.

You could just use GitHub Actions .
You add a web hook for your applications artifacts and deploy them to AWS.
lke this mabe

name: Deploy to AWS

on:
  push:
    branches:
      - main

jobs:
  deploy_nodejs:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

    - name: Install Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '14'

    - name: Install dependencies
      run: npm install

    - name: Build application
      run: npm run build

    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v2
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: us-east-1

    - name: Deploy to AWS
      run: |
        aws s3 sync dist s3://your-bucket-name
        aws cloudfront create-invalidation --distribution-id YOUR_DISTRIBUTION_ID --paths "/*"

I've recently used GitHub Actions to deploy Python Flask application on Lambda using ECR images, glue jobs, and found it very helpful.

In past I've used Bitbucket pipelines to deploy Java Spring Boot application on ElasticBeanstalk.

Both of the tools are flexible, Bitbucket pipelines are older in the game therefore have move connectors and helpful option but I've not found hard limitation with GitHub Actions either.

Well, as everybody already response. Github Actions is a good choice to start because it uses a hybrid cloud strategy. It hosts its own job runners and also lets users host their own job runners. On the other hand, Jenkins deployments generally involve self-hosting, where the users oversee servers in their own data centers.

In my experience I'd been working with both and the choice to use one or another always should be depends on the policies of the company or solution architecture.

If you intend to practice infrastructure as code with Cloudformation/CDK, try out AWS CodePipeline. It'll be easier to integrate with AWS related services.

You can use github actions if you have code in github but if you want AWS ecosystem, you can use aws codepipeline along with aws code commit

Github actions will probably be the easiest to use.

If you break into aws gear, you have CodeBuild, CodeDeploy and CodePipeline you can use. I'd suggest going just CodeBuild. Run a laravel deploy right in the build with ssm send command to kick off a deploy on the ec2.

Try using UserData in ec2. When you have a new version, spin up a new ec2 and put the code to install the latest code right in the UserData that runs code at launch for the ec2.

Then just point to the new ec2 and if it works throw away the old one.

Check out containers. Put your build artifacts in s3 and have the dockers or ec2s pull in the artifacts when they spin up.

My point is to divorce the server from the deploy process. It's better to make a new thing than modify a thing. If you modify an artifact in production... eventually, you will forget how to build from scratch. If you always build from scratch, your recovery process will be the same as your deploy process and you'll have total faith in it because you always use it.

For a solo developer managing Node.js and PHP Laravel applications on GitHub with AWS chosen as the cloud provider, the most reliable and convenient CI/CD setup would depend on factors like team size, workflow frequency, and Docker Hub limitations.

Considering your scenario:

1. Team Size and Workflow Frequency:

   • As a solo developer, your CI/CD workflow frequency might be moderate, depending on your development pace and requirements.

   • Example: Running CI/CD workflows multiple times per day (e.g., 3-5 times per day) to ensure frequent testing and deployment.

2. Docker Hub Registry Limitations:

   • Docker Hub's free tier has limitations on the number of private repositories and image pulls, which might pose constraints as your projects grow.

   • Example: With multiple applications and frequent CI/CD runs, you may quickly reach Docker Hub's limitations, impacting your workflow efficiency.

Given these considerations, here's the recommended approach:

CI/CD Setup:

• Utilize GitHub Actions for CI/CD workflows due to its seamless integration with GitHub repositories and flexibility in workflow configuration.

• Leverage AWS Elastic Container Registry (ECR) for Docker container image storage and management, ensuring scalability and reliability without constraints on repository count or image pulls.

Advantages:

• GitHub Actions allows you to define CI/CD pipelines directly within your GitHub repository, simplifying setup and maintenance.

• AWS ECR provides a scalable and reliable solution for storing Docker images, ensuring consistent availability and performance without limitations.

Conclusion: Considering your solo developer status, moderate workflow frequency, and potential Docker Hub limitations, the most reliable and convenient CI/CD setup for your projects would involve using GitHub Actions for workflow automation and AWS ECR for Docker image storage. This approach ensures seamless integration, scalability, and reliability for your CI/CD pipeline as you continue to develop and deploy your Node.js and PHP Laravel applications.

I would suggest:

1. GitHub Actions: GitHub Actions is a powerful CI/CD platform built directly into GitHub.

2. Jenkins: Jenkins is a widely adopted open-source automation server. Jenkins integrates smoothly with GitHub through plugins, allowing you to trigger builds and deployments based on events in your GitHub repositories.

I would use GitHub Actions. Here is a pretty good article by AWS.

I recommend using GitHub actions

1. Create a mono repository with both projects.

2. Create a build script that builds and prepares your nodejs and php project for production

3. Introduce the aws cdk that can deploy your built assets to something like S3

4. Introduce a github action/workflow with a push trigger that runs your build script and also runs cdk synth and cdk deploy

I can advise you to use Jenkins, it is very easy and good for CI CD.

I have try it before and you can setup a trigger for a specific action did in your GitHub repository

They are all the same at the end of the day. Since you have code on Github, I suggest GitHub actions. You can set up OIDC with GitHub to access your AWS account.

You should use Github Actions. You can get some help from the below URLs

https://github.com/sdras/awesome-actions
https://docs.github.com/en/actions

In my perspective I assume using Gitlab CI/CD is the most efficient becuase of its pipe line that has and it can test your application before pushing it into the server

Also Jenkins has reputation for CI/CD deployment but I think Gitlab is much more handy

but If you are begginer and it is your first experiment to CI/CD I suggest you the github action which is very easy to learn and also it is ready to learn in the github

you can find it in this link

GitHub Action as a ton of CI/CD tools you can use that suit your needs for your project.