Abstract:
This article provides a guide on deploying a Laravel project on shared hosting with cPanel, utilizing Github Actions for Continuous Integration/Continuous Deployment (CI/CD) in scenarios where SSH access is restricted.
Introduction:
Shared hosting is a cost-effective alternative to VPS, but some hosting providers may limit SSH access for various reasons. Despite this limitation, FTP access is often available. This article demonstrates how to leverage Github Actions and FTP to establish a CI/CD pipeline for deploying Laravel projects on shared hosting without SSH access.
Getting Started:
Follow these step-by-step instructions:
1. Setting up FTP Account
Step 1: Log in to your cPanel and navigate to FTP Account.
2. Adding the FTP Account:
3. Retrieving FTP Account Details:
Step 3: Access the FTP Client within cPanel to retrieve the necessary account details.
4. Copy and Save FTP Credentials:
Step 4: Copy the FTP Username and FTP Server information obtained from the FTP Client and securely save it for future use in the CI/CD setup.
Setting up GitHub Actions for Laravel CI/CD with cPanel
Shared Hosting:
Step 1: Open the GitHub repository you wish to automate and navigate to the "Actions" tab.
Step 2: Click on the highlighted link within the Actions tab.
Step 3: Access Settings and go to Actions under the Secrets and Variables dropdown.
Step 4: Create a new repository secret, utilizing the
FTP account values obtained earlier.
To maintain security, sensitive server access information should not be included in the source code. GitHub provides a solution by allowing developers to pass critical variables securely. Open the repository settings, navigate to the Security section, and click on Secrets and Variables. Under Actions, insert SERVER, USERNAME, and PASSWORD.
Step 5: Copy the provided YAML file and save it as
main.yml, then commit the changes.
main.yml
Completion: The CI/CD pipeline is now set up. By
pushing or merging new code into the main branch, the CI/CD process will be
triggered.
Hint: The initial setup may take some time, but
subsequent executions will be faster.
Abstract:
This article provides a guide on deploying a Laravel project on shared hosting with cPanel, utilizing Github Actions for Continuous Integration/Continuous Deployment (CI/CD) in scenarios where SSH access is restricted.
Introduction:
Shared hosting is a cost-effective alternative to VPS, but some hosting providers may limit SSH access for various reasons. Despite this limitation, FTP access is often available. This article demonstrates how to leverage Github Actions and FTP to establish a CI/CD pipeline for deploying Laravel projects on shared hosting without SSH access.
Getting Started:
Follow these step-by-step instructions:
1. Setting up FTP Account
Step 1: Log in to your cPanel and navigate to FTP Account.
2. Adding the FTP Account:
3. Retrieving FTP Account Details:
Step 3: Access the FTP Client within cPanel to retrieve the necessary account details.
4. Copy and Save FTP Credentials:
Step 4: Copy the FTP Username and FTP Server information obtained from the FTP Client and securely save it for future use in the CI/CD setup.
Setting up GitHub Actions for Laravel CI/CD with cPanel
Shared Hosting:
Step 1: Open the GitHub repository you wish to automate and navigate to the "Actions" tab.
Step 2: Click on the highlighted link within the Actions tab.
Step 3: Access Settings and go to Actions under the Secrets and Variables dropdown.
Step 4: Create a new repository secret, utilizing the
FTP account values obtained earlier.
To maintain security, sensitive server access information should not be included in the source code. GitHub provides a solution by allowing developers to pass critical variables securely. Open the repository settings, navigate to the Security section, and click on Secrets and Variables. Under Actions, insert SERVER, USERNAME, and PASSWORD.
Step 5: Copy the provided YAML file and save it as
main.yml, then commit the changes.
main.yml
Completion: The CI/CD pipeline is now set up. By
pushing or merging new code into the main branch, the CI/CD process will be
triggered.
Hint: The initial setup may take some time, but
subsequent executions will be faster.
🔹 Smoke Testing:
📍Purpose: This is a preliminary test to ensure that the basic functionalities of the API are working without any major issues.
📍Process: It involves executing a set of basic tests on the API to validate its core functionalities.
📍Example: Sending a simple request to the API and checking if it returns the expected response code.
🔹 Functional Testing:
📍Purpose: To verify that the API functions according to the specified functional requirements.
📍Process: Test cases are designed based on the functional requirements, and the actual outcomes are compared against expected results.
📍Example: Testing different endpoints with various inputs to ensure correct behavior.
🔹 Integration Testing:
📍Purpose: To test the interaction between different components or APIs within the system.
📍Process: Multiple API calls are combined to perform end-to-end testing, ensuring proper communication and data transmission between services.
📍Example: Testing a payment API along with an inventory management API to ensure seamless order processing.
🔹 Regression Testing:
📍Purpose: To ensure that changes or updates to the API do not negatively impact existing functionalities.
📍Process: Previously executed test cases are re-run to confirm that existing functionalities are still working as expected.
📍Example: Repeating tests for core functionalities after implementing a new feature to ensure no regression occurs.
🔹 Load Testing:
📍Purpose: To assess the performance of the API under different loads by simulating concurrent user interactions.
📍Process: APIs are subjected to varying levels of traffic to determine their capacity and response times under stress.
📍Example: Sending a large number of simultaneous requests to the API to assess its performance under peak load conditions.
🔹 Stress Testing:
📍Purpose: To evaluate the API's stability and robustness under extreme conditions, beyond its normal operational capacity.
📍Process: APIs are subjected to high loads or resource exhaustion to determine their breaking points and how they recover.
📍Example: Generating a massive influx of requests to the API to assess its ability to handle unexpected spikes in traffic.
🔹 Security Testing:
📍Purpose: To identify and mitigate vulnerabilities in the API that could be exploited by malicious actors.
📍Process: APIs are tested against various security threats and attacks to ensure data integrity, confidentiality, and availability.
📍Example: Checking for proper authentication mechanisms, encryption of sensitive data, and protection against common security threats like SQL injection or Cross-Site Scripting (XSS).
🔹 UI Testing:
📍Purpose: To verify that the data retrieved from the API is correctly displayed and interacted with in the user interface.
📍Process: Testing the integration between the UI and API to ensure seamless interaction and accurate data presentation.
📍Example: Validating that user input through the UI correctly triggers API calls and that the displayed data matches the API response.
🔹 Fuzz Testing:
📍Purpose: To identify potential vulnerabilities or weaknesses in the API by sending unexpected or invalid inputs.
📍Process: Injecting malformed or random data into the API endpoints to provoke unexpected behaviors or crashes.
📍Example: Sending random strings, special characters, or excessively large payloads to API endpoints to test how they handle unexpected inputs.
🔹 Smoke Testing:
📍Purpose: This is a preliminary test to ensure that the basic functionalities of the API are working without any major issues.
📍Process: It involves executing a set of basic tests on the API to validate its core functionalities.
📍Example: Sending a simple request to the API and checking if it returns the expected response code.
🔹 Functional Testing:
📍Purpose: To verify that the API functions according to the specified functional requirements.
📍Process: Test cases are designed based on the functional requirements, and the actual outcomes are compared against expected results.
📍Example: Testing different endpoints with various inputs to ensure correct behavior.
🔹 Integration Testing:
📍Purpose: To test the interaction between different components or APIs within the system.
📍Process: Multiple API calls are combined to perform end-to-end testing, ensuring proper communication and data transmission between services.
📍Example: Testing a payment API along with an inventory management API to ensure seamless order processing.
🔹 Regression Testing:
📍Purpose: To ensure that changes or updates to the API do not negatively impact existing functionalities.
📍Process: Previously executed test cases are re-run to confirm that existing functionalities are still working as expected.
📍Example: Repeating tests for core functionalities after implementing a new feature to ensure no regression occurs.
🔹 Load Testing:
📍Purpose: To assess the performance of the API under different loads by simulating concurrent user interactions.
📍Process: APIs are subjected to varying levels of traffic to determine their capacity and response times under stress.
📍Example: Sending a large number of simultaneous requests to the API to assess its performance under peak load conditions.
🔹 Stress Testing:
📍Purpose: To evaluate the API's stability and robustness under extreme conditions, beyond its normal operational capacity.
📍Process: APIs are subjected to high loads or resource exhaustion to determine their breaking points and how they recover.
📍Example: Generating a massive influx of requests to the API to assess its ability to handle unexpected spikes in traffic.
🔹 Security Testing:
📍Purpose: To identify and mitigate vulnerabilities in the API that could be exploited by malicious actors.
📍Process: APIs are tested against various security threats and attacks to ensure data integrity, confidentiality, and availability.
📍Example: Checking for proper authentication mechanisms, encryption of sensitive data, and protection against common security threats like SQL injection or Cross-Site Scripting (XSS).
🔹 UI Testing:
📍Purpose: To verify that the data retrieved from the API is correctly displayed and interacted with in the user interface.
📍Process: Testing the integration between the UI and API to ensure seamless interaction and accurate data presentation.
📍Example: Validating that user input through the UI correctly triggers API calls and that the displayed data matches the API response.
🔹 Fuzz Testing:
📍Purpose: To identify potential vulnerabilities or weaknesses in the API by sending unexpected or invalid inputs.
📍Process: Injecting malformed or random data into the API endpoints to provoke unexpected behaviors or crashes.
📍Example: Sending random strings, special characters, or excessively large payloads to API endpoints to test how they handle unexpected inputs.
Git and GitHub are indispensable tools in modern software development, providing version control and collaboration capabilities that streamline the development process. Adopting best practices in using Git and GitHub can significantly improve the efficiency, quality, and reliability of your projects. This blog explores some of the best practices to follow.
1. Write Meaningful Commit Messages
A commit message should clearly explain what changes have been made and why. A well-crafted commit message helps others understand the history and purpose of changes, making collaboration more effective.
Guidelines:
• Start with a capital letter and use the imperative mood: E.g., "Add feature X", "Fix bug Y".
• Keep it concise but descriptive: Summarize the changes in about 50 characters.
• Use the body for details: If needed, provide a more detailed explanation after the summary.
2. Branching Strategy
Adopt a branching strategy that supports parallel development and easy integration of new features. Common strategies include:
Git Flow:
• master: Production-ready code.
• develop: Integration branch for new features.
• feature/branch: New features branched off from develop.
• release/branch: Preparation for production releases.
• hotfix/branch: Quick fixes for production issues.
GitHub Flow:
• main: Production-ready code.
• feature/branch: New features branched off from main and merged back into main.
3. Pull Requests (PRs)
Use Pull Requests to review code before merging it into the main branch. PRs facilitate collaboration, catch bugs, and improve code quality.
Guidelines:
• Small, focused PRs: Aim for smaller PRs that are easier to review.
• Detailed descriptions: Explain what the PR does and why.
• Request reviews: Tag relevant team members for review.
4. Code Reviews
Conduct thorough code reviews to maintain high code quality. Reviewers should focus on functionality, readability, security, and performance.
Guidelines:
• Be constructive: Provide positive feedback and suggest improvements.
• Follow guidelines: Ensure adherence to coding standards and guidelines.
• Test thoroughly: Verify that the code works as expected and does not introduce new bugs.
5. Consistent Workflow
Adopt a consistent workflow across your team to reduce confusion and streamline collaboration. Standardize how you create branches, write commit messages, and handle PRs.
Guidelines:
• Document the workflow: Create a contribution guide.
• Automate with templates: Use issue and PR templates.
6. Automate with GitHub Actions
Use GitHub Actions to automate workflows such as testing, building, and deploying your code. Automation ensures consistency and saves time.
7. Protect the Main Branch
Protect your main branch by enforcing policies such as requiring PR reviews, passing status checks, and prohibiting direct commits.
Guidelines:
• Require PR reviews: Ensure code is reviewed before merging.
• Status checks: Enforce passing tests before merging.
• Branch protection: Prevent force pushes and deletions.
8. Tagging and Releases
Use tags to mark significant points in your project's history, such as releases. This makes it easier to track versions and deploy specific versions.
Guidelines:
• Semantic versioning: Use MAJOR.MINOR.PATCH format.
• Annotated tags: Include a message with the tag.
Conclusion
Adopting these best practices in Git and GitHub will help you maintain a clean, organized, and efficient workflow. Consistent use of meaningful commit messages, a well-defined branching strategy, thorough code reviews, and automation will improve collaboration and code quality in your projects. Remember to document your processes and ensure all team members are on the same page to maximize the benefits of these practices.
";s:10:"short_desc";N;s:10:"updated_at";s:19:"2024-05-30 03:21:58";s:10:"created_at";s:19:"2024-05-30 03:20:24";s:7:"user_id";N;s:4:"name";s:24:"Morris Muriuki Muthigani";s:8:"postlike";i:0;s:10:"postunlike";i:0;s:9:"user_name";s:10:"mmuthigani";s:11:"cover_image";s:52:"best-practices-in-git-and-github2024-05-30 06:20.jpg";s:4:"tags";s:6:"others";s:11:"likes_count";i:65;}s:11:" * original";a:16:{s:2:"id";i:53;s:4:"slug";s:32:"best-practices-in-git-and-github";s:5:"title";s:32:"Best Practices in Git and GitHub";s:9:"imageData";N;s:11:"description";s:5236:"Git and GitHub are indispensable tools in modern software development, providing version control and collaboration capabilities that streamline the development process. Adopting best practices in using Git and GitHub can significantly improve the efficiency, quality, and reliability of your projects. This blog explores some of the best practices to follow.
1. Write Meaningful Commit Messages
A commit message should clearly explain what changes have been made and why. A well-crafted commit message helps others understand the history and purpose of changes, making collaboration more effective.
Guidelines:
• Start with a capital letter and use the imperative mood: E.g., "Add feature X", "Fix bug Y".
• Keep it concise but descriptive: Summarize the changes in about 50 characters.
• Use the body for details: If needed, provide a more detailed explanation after the summary.
2. Branching Strategy
Adopt a branching strategy that supports parallel development and easy integration of new features. Common strategies include:
Git Flow:
• master: Production-ready code.
• develop: Integration branch for new features.
• feature/branch: New features branched off from develop.
• release/branch: Preparation for production releases.
• hotfix/branch: Quick fixes for production issues.
GitHub Flow:
• main: Production-ready code.
• feature/branch: New features branched off from main and merged back into main.
3. Pull Requests (PRs)
Use Pull Requests to review code before merging it into the main branch. PRs facilitate collaboration, catch bugs, and improve code quality.
Guidelines:
• Small, focused PRs: Aim for smaller PRs that are easier to review.
• Detailed descriptions: Explain what the PR does and why.
• Request reviews: Tag relevant team members for review.
4. Code Reviews
Conduct thorough code reviews to maintain high code quality. Reviewers should focus on functionality, readability, security, and performance.
Guidelines:
• Be constructive: Provide positive feedback and suggest improvements.
• Follow guidelines: Ensure adherence to coding standards and guidelines.
• Test thoroughly: Verify that the code works as expected and does not introduce new bugs.
5. Consistent Workflow
Adopt a consistent workflow across your team to reduce confusion and streamline collaboration. Standardize how you create branches, write commit messages, and handle PRs.
Guidelines:
• Document the workflow: Create a contribution guide.
• Automate with templates: Use issue and PR templates.
6. Automate with GitHub Actions
Use GitHub Actions to automate workflows such as testing, building, and deploying your code. Automation ensures consistency and saves time.
7. Protect the Main Branch
Protect your main branch by enforcing policies such as requiring PR reviews, passing status checks, and prohibiting direct commits.
Guidelines:
• Require PR reviews: Ensure code is reviewed before merging.
• Status checks: Enforce passing tests before merging.
• Branch protection: Prevent force pushes and deletions.
8. Tagging and Releases
Use tags to mark significant points in your project's history, such as releases. This makes it easier to track versions and deploy specific versions.
Guidelines:
• Semantic versioning: Use MAJOR.MINOR.PATCH format.
• Annotated tags: Include a message with the tag.
Conclusion
Adopting these best practices in Git and GitHub will help you maintain a clean, organized, and efficient workflow. Consistent use of meaningful commit messages, a well-defined branching strategy, thorough code reviews, and automation will improve collaboration and code quality in your projects. Remember to document your processes and ensure all team members are on the same page to maximize the benefits of these practices.
";s:10:"short_desc";N;s:10:"updated_at";s:19:"2024-05-30 03:21:58";s:10:"created_at";s:19:"2024-05-30 03:20:24";s:7:"user_id";N;s:4:"name";s:24:"Morris Muriuki Muthigani";s:8:"postlike";i:0;s:10:"postunlike";i:0;s:9:"user_name";s:10:"mmuthigani";s:11:"cover_image";s:52:"best-practices-in-git-and-github2024-05-30 06:20.jpg";s:4:"tags";s:6:"others";s:11:"likes_count";i:65;}s:10:" * changes";a:0:{}s:8:" * casts";a:0:{}s:17:" * classCastCache";a:0:{}s:21:" * attributeCastCache";a:0:{}s:13:" * dateFormat";N;s:10:" * appends";a:0:{}s:19:" * dispatchesEvents";a:0:{}s:14:" * observables";a:0:{}s:12:" * relations";a:0:{}s:10:" * touches";a:0:{}s:10:"timestamps";b:1;s:13:"usesUniqueIds";b:0;s:9:" * hidden";a:0:{}s:10:" * visible";a:0:{}s:11:" * fillable";a:0:{}s:10:" * guarded";a:1:{i:0;s:1:"*";}}}s:28:" * escapeWhenCastingToString";b:0;}s:10:" * perPage";i:9;s:14:" * currentPage";i:4;s:7:" * path";s:44:"https://kikimoapi.kikimodev.com/public/blogs";s:8:" * query";a:0:{}s:11:" * fragment";N;s:11:" * pageName";s:4:"page";s:10:"onEachSide";i:3;s:10:" * options";a:2:{s:4:"path";s:44:"https://kikimoapi.kikimodev.com/public/blogs";s:8:"pageName";s:4:"page";}s:8:" * total";i:30;s:11:" * lastPage";i:4;}