Auto Deploy SFTP AWS

### Step 1: Set Up Your AWS Server for SFTP

1. **Install an SFTP Server**: Ensure your AWS server (like EC2) has an SFTP server running. Typically, the default SSH service supports SFTP.
2. **Create a User for SFTP**: Create a new user that has SFTP access to your desired directory.

### Step 2: Generate SSH Keys

1. **Generate SSH Keys** on your local machine if you don't have them already:

ssh-keygen -t rsa -b 2048

Save the key pair and remember the paths (default is usually `~/.ssh/id_rsa` and `~/.ssh/id_rsa.pub`).

2. **Copy the Public Key to the AWS Server**:

ssh-copy-id -i ~/.ssh/id_rsa.pub user@your-server-ip

### Step 3: Create a Post-Receive Hook

1. **On your AWS server**, navigate to your desired deployment directory:

cd /path/to/your/deployment/directory

2. **Create a Git repository** in that directory (if you haven't already):

git init

3. **Set up the Git hook**:
– Navigate to the hooks directory:

cd .git/hooks

– Create a `post-receive` file:

touch post-receive

– Make the `post-receive` file executable:

chmod +x post-receive

– Edit the `post-receive` file and add the following script:

#!/bin/bash
     GIT_WORK_TREE=/path/to/your/deployment/directory git checkout -f master

### Step 4: Push Your Changes

1. **From your local machine**, add the AWS server as a remote repository:

git remote add aws sftp://user@your-server-ip/path/to/your/repo.git

2. **Push your changes to the AWS server**:

git push aws master

### Step 5: Automate the Deployment (Optional)

If you want to automate the deployment using CI/CD tools:

#### Using GitHub Actions

1. **Create a workflow file** in your repository (e.g., `.github/workflows/deploy.yml`):

name: Deploy to AWS SFTP

   on:
     push:
       branches:
         - master

   jobs:
     deploy:
       runs-on: ubuntu-latest

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

         - name: Install SSH client
           run: sudo apt-get install openssh-client

         - name: Deploy to server
           run: |
             echo "$SSH_PRIVATE_KEY" | tr -d 'r' | ssh-add -
             ssh -o StrictHostKeyChecking=no user@your-server-ip "cd /path/to/your/deployment/directory && git pull"
           env:
             SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}

2. **Add your private SSH key** to your repository secrets as `SSH_PRIVATE_KEY`.

### Conclusion

Now, every time you push to the master branch, your application will be automatically deployed to your AWS server via SFTP. You can adjust this setup based on your project's structure and specific requirements. Let me know if you need further assistance!

### Step 1: Verify SFTP Service on the AWS Instance

1. **Connect to Your AWS Instance**:
Use SSH to connect to your AWS EC2 instance. Replace `your-key.pem`, `ec2-user`, and `your-instance-ip` with your actual key file, username, and instance IP.

ssh -i /path/to/your-key.pem ec2-user@your-instance-ip

2. **Check the SSH Service**:
SFTP operates over SSH, so ensure the SSH service is running. You can check the status of the SSH service with:

sudo systemctl status sshd

If it's not running, you can start it with:

sudo systemctl start sshd

### Step 2: Test SFTP Connection

1. **Use an SFTP Client**:
You can use an SFTP client like FileZilla, WinSCP, or command line tools to connect to your server. Here’s how to use the command line:

Open a terminal and run:

sftp -i /path/to/your-key.pem ec2-user@your-instance-ip

If you have set up a different user for SFTP, replace `ec2-user` with that username.

2. **Enter Password or Use Key**:
If prompted, enter the password for the user or ensure that your private key is correctly specified with the `-i` option.

### Step 3: Navigate and Test File Transfer

1. **List Files**:
Once connected, you can list files in the home directory using:

ls

2. **Upload a File**:
To upload a file from your local machine to the server, use the `put` command:

put /path/to/local/file.txt

3. **Download a File**:
To download a file from the server to your local machine, use the `get` command:

get remote-file.txt

4. **Exit the SFTP Session**:
To exit the SFTP session, simply type:

exit

### Step 4: Check Security Group and Firewall Rules

1. **AWS Security Groups**:
Ensure that your EC2 instance's security group allows inbound traffic on port 22 (SSH/SFTP). You can check this in the AWS Management Console:
– Go to the **EC2 Dashboard**.
– Click on **Instances**.
– Select your instance and click on the **Security** tab.
– Check the **Inbound rules**. Ensure there's a rule that allows TCP traffic on port 22 from your IP address.

2. **Firewall Settings**:
If you have a firewall running on your instance (like `ufw` or `iptables`), ensure that it allows SFTP traffic on port 22.

### Conclusion

By following these steps, you should be able to check and verify if SFTP is working properly on your AWS server. If you encounter any issues or errors, feel free to share them, and I'll help troubleshoot further!

### Step 1: Verify SFTP Service on Your Ubuntu Instance

1. **Connect to Your AWS Instance**:
Use SSH to connect to your Ubuntu EC2 instance. Replace `your-key.pem`, `ubuntu`, and `your-instance-ip` with your actual key file, username, and instance IP.

ssh -i /path/to/your-key.pem ubuntu@your-instance-ip

2. **Check the SSH Service**:
SFTP operates over SSH. You can verify that the SSH service is running with:

sudo systemctl status ssh

If it's not running, you can start it with:

sudo systemctl start ssh

### Step 2: Test SFTP Connection

1. **Use the Command Line to Connect via SFTP**:
From your local machine, you can test the SFTP connection using:

sftp -i /path/to/your-key.pem ubuntu@your-instance-ip

If you have set up a different user for SFTP, replace `ubuntu` with that username.

2. **Check for Successful Connection**:
If the connection is successful, you should see a prompt indicating that you are connected.

### Step 3: Navigate and Test File Transfer

1. **List Files**:
After connecting, list files in the home directory:

ls

2. **Upload a File**:
To upload a file from your local machine to the server:

put /path/to/local/file.txt

3. **Download a File**:
To download a file from the server to your local machine:

get remote-file.txt

4. **Exit the SFTP Session**:
Type `exit` to leave the SFTP session.

### Step 4: Check Security Group and Firewall Rules

1. **AWS Security Groups**:
Make sure your EC2 instance's security group allows inbound traffic on port 22 (SSH/SFTP):
– Go to the **EC2 Dashboard**.
– Click on **Instances**.
– Select your instance and click on the **Security** tab.
– Verify the **Inbound rules** for a rule that allows TCP traffic on port 22 from your IP address.

2. **Check UFW Firewall** (if enabled):
If you are using `ufw` (Uncomplicated Firewall), ensure that it allows SSH/SFTP traffic:

sudo ufw status

If SSH is not allowed, enable it with:

sudo ufw allow ssh

### Step 5: Configuring SFTP for Users (Optional)

If you want to set up SFTP for a specific user:

1. **Create a User**:

sudo adduser sftpuser

2. **Create a Directory for SFTP**:

sudo mkdir -p /home/sftpuser/uploads

3. **Set Permissions**:

sudo chown root:root /home/sftpuser
   sudo chmod 755 /home/sftpuser
   sudo chown sftpuser:sftpuser /home/sftpuser/uploads

4. **Configure SSH for SFTP**:
Edit the SSH configuration file:

sudo nano /etc/ssh/sshd_config

Add the following at the end of the file:

Match User sftpuser
       ChrootDirectory /home/sftpuser
       ForceCommand internal-sftp
       AllowTcpForwarding no

5. **Restart SSH Service**:

sudo systemctl restart ssh

### Conclusion

These steps should help you verify and set up SFTP on your Ubuntu instance on AWS. If you encounter any issues or need further assistance, let me know!

### Option 1: Using Git Hooks for Automatic Deployment

1. **Set Up Your Git Repository on the Server**:
– SSH into your AWS server.
– Navigate to the directory where you want to deploy your application:

cd /path/to/your/deployment/directory

– Initialize a bare Git repository:

git init --bare

2. **Create a Post-Receive Hook**:
– Navigate to the hooks directory:

cd /path/to/your/deployment/directory.git/hooks

– Create a `post-receive` file:

touch post-receive

– Make the `post-receive` file executable:

chmod +x post-receive

– Edit the `post-receive` file and add the following script:

#!/bin/bash
     GIT_WORK_TREE=/path/to/your/deployment/directory git checkout -f master

– This will automatically check out the latest version of the master branch whenever there is a push to the bare repository.

3. **Set Up Your Local Repository**:
– On your local machine, add your AWS server as a remote repository:

git remote add aws sftp://username@your-server-ip/path/to/your/deployment/directory.git

– Push to the AWS server to trigger the deployment:

git push aws master

### Option 2: Using GitHub Actions for Automatic Deployment

If you want to use a CI/CD tool like GitHub Actions to automate the deployment process, follow these steps:

1. **Create a Deployment Script**:
– On your local machine, create a shell script for deployment. For example, create a file named `deploy.sh`:

#!/bin/bash
     HOST="your-server-ip"
     USER="username"
     KEY="/path/to/your-key.pem"
     REMOTE_DIR="/path/to/your/deployment/directory"

     # Sync files using SFTP
     sftp -i "$KEY" "$USER@$HOST" << EOF
     put -r /path/to/your/local/directory/* $REMOTE_DIR
     bye
     EOF

– Make the script executable:

chmod +x deploy.sh

2. **Set Up GitHub Actions**:
– In your GitHub repository, create a directory for workflows if it doesn't exist:

.github/workflows

– Create a new workflow file, e.g., `deploy.yml`:

name: Deploy to AWS SFTP

     on:
       push:
         branches:
           - master

     jobs:
       deploy:
         runs-on: ubuntu-latest

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

           - name: Install SSH client
             run: sudo apt-get install openssh-client

           - name: Deploy to SFTP
             run: |
               chmod 600 ${{ secrets.SSH_KEY }}
               sftp -i ${{ secrets.SSH_KEY }} -o StrictHostKeyChecking=no username@your-server-ip << EOF
               put -r * /path/to/your/deployment/directory
               bye
               EOF
             env:
               SSH_KEY: ${{ secrets.SSH_KEY }}

3. **Add Your SSH Key to GitHub Secrets**:
– Go to your GitHub repository.
– Click on **Settings** > **Secrets and variables** > **Actions**.
– Add a new secret named `SSH_KEY` and paste your private key content.

4. **Trigger Deployment**:
– Now, every time you push to the master branch, GitHub Actions will run the workflow and deploy your application to your AWS server via SFTP.

### Conclusion

You can choose either the Git hook method for a simpler setup or use GitHub Actions for a more automated CI/CD pipeline. If you have further questions or need additional help, feel free to ask!

### 1. From the Local Repository

If you are inside a local Git repository on your terminal, you can find the repository name by checking the remote configuration.

– **Using the Command Line**:

git remote -v

This command will list the remotes associated with your repository along with their URLs. The repository name can typically be derived from the URL. For example, in a URL like `https://github.com/username/repository.git`, the repository name is `repository`.

### 2. From the Remote Repository (e.g., GitHub)

If you want to find the repository name on a remote service like GitHub:

– **Using the Web Interface**:
– Log in to your GitHub account.
– Navigate to your repositories by clicking on your profile icon and selecting **Your repositories**.
– The list of your repositories will be displayed, and you can find the repository name there.

### 3. Using GitHub CLI (If Installed)

If you have the GitHub CLI (`gh`) installed, you can also find the repository name using:

gh repo view --json name

### 4. From the `.git/config` File

You can also check the repository name by looking at the `.git/config` file in your local repository:

1. Navigate to your repository directory:

cd /path/to/your/repository

2. Open the `.git/config` file:

cat .git/config

3. Look for the `remote` section. The URL here will contain the repository name, similar to the `git remote -v` output.

### Conclusion

Using any of the methods above, you can easily find the name of your Git repository. If you have a specific context or need further assistance, feel free to ask!

### Step 1: Check the Deployment Logs

1. **AWS Console**:
– Go to the **AWS Management Console**.
– Navigate to the service you are using for deployment (e.g., CodeDeploy, Elastic Beanstalk, etc.).
– Look for the **Deployment** section and view the logs or events associated with the failed deployment. This often provides specific error messages or reasons for the failure.

2. **Logs**:
– Check the application and system logs for more details. For instance, if you're using Elastic Beanstalk, you can view logs under the **Logs** section.
– In CodeDeploy, check the logs on the EC2 instances in the `/var/log/codedeploy-agent` directory.

### Step 2: Verify Instance Health

1. **Check Instance Status**:
– In the AWS console, go to **EC2** and check the status of your instances. Ensure they are in a **running** state and are healthy.
– Look for any instances that are in a **stopped**, **terminated**, or **pending** state, as these may indicate issues.

2. **Health Checks**:
– If you're using Auto Scaling groups, ensure that the health check settings are configured properly. Instances might be marked as unhealthy if they fail health checks.

### Step 3: Inspect Deployment Configuration

1. **Deployment Group**:
– Check your deployment group settings. Ensure that the minimum healthy hosts percentage is set correctly. If it's too high, it might prevent successful deployments when instances are unhealthy.
– Make sure that the correct IAM roles and permissions are assigned.

2. **Deployment Settings**:
– If using CodeDeploy, verify that the `appspec.yml` file is correctly configured and includes all necessary hooks and scripts.

### Step 4: Troubleshoot Application Issues

1. **Application Errors**:
– Investigate any application-specific errors that might be causing instances to fail. Look for syntax errors, missing dependencies, or incorrect configurations in your code.
– If the application depends on environment variables or configuration files, ensure they are set correctly in your deployment.

2. **Rollback Strategy**:
– If you have a rollback strategy set up, consider rolling back to a previous version that was known to be healthy.

### Step 5: Retry Deployment

After investigating and addressing any identified issues, try redeploying your application. Monitor the deployment closely to catch any further issues as they arise.

### Step 6: AWS Support

If you're still unable to resolve the issue, consider reaching out to AWS Support for assistance. They can provide deeper insights into your specific deployment setup and logs.

### Conclusion

By following these steps, you should be able to identify the cause of the deployment failure and take the necessary actions to resolve it. If you need more detailed assistance based on the specific service you're using, please let me know!