Build the foundations for a Software as a Service business by leveraging Django, Tailwind, htmx, Vue.js, and more. The goal of this project is to learn how to create a reusable foundation for building SaaS products. When release, this course will span multiple topics and give you a solid foundation into build your business. ## Prerequisites - Django experience with [Your First Django Project](https://www.codingforentrepreneurs.com/courses/your-first-django-project/), a [Try Django](https://www.codingforentrepreneurs.com/topics/try-django/) series, or similar. - Python experience with [30 Days of Python](https://www.codingforentrepreneurs.com/courses/30-days-python-38/) or similar. - Vue experience with [Predict Input](https://www.codingforentrepreneurs.com/courses/predict-input/) or [Django x Vue](https://www.codingforentrepreneurs.com/courses/django-vuejs-3/)

## Master Web Scraping with Django, Celery, Selenium, and Bright Data! 🚀 Unlock the full potential of web scraping and automation in this comprehensive tutorial. Learn how to seamlessly integrate Django with Celery for efficient task management, utilize Selenium for advanced browser automation, and leverage Bright Data for effective proxy scraping. This course is designed to equip you with the practical skills needed to gather data from the web efficiently, process it, and use it to drive insights for your projects. Whether you're looking to enhance your data analysis capabilities or build a robust data-driven application, this tutorial sets a solid foundation for your journey. ### Topics Covered: ⦿ Integrating Django with Celery for background task processing ⦿ First-hand experience with Selenium in Jupyter for live browser automation ⦿ Advanced proxy scraping techniques using Bright Data and Selenium ⦿ Building helper functions to streamline your scraping module ⦿ Combining Django and Jupyter for an enhanced development experience ⦿ Data parsing with BeautifulSoup4, including handling complex challenges like Amazon Captchas ⦿ Efficient data storage using Django models ⦿ Offloading heavy scraping tasks with Celery for improved application performance ⦿ Automating and scheduling scraping tasks within the Django admin using Celery ⦿ Plus, much more in-depth knowledge and practical tips! By the end of this tutorial, you'll have a well-rounded understanding of how to set up, execute, and manage large-scale web scraping projects with Django, making your data collection process as seamless and efficient as possible. Don't miss out on the opportunity to enhance your web scraping skills and take your projects to the next level. Join us now and start building a solid foundation for your data-driven aspirations! ### References - [Code](https://github.com/codingforentrepreneurs/Web-Scraping-with-Django-Celery) - [Bright Data $25 Promo Credit](https://brdta.com/justin)

Embark on a Serverless Development Odyssey in the **Serverless Node.js API with Express and AWS Lambda* Course Transform your development journey with our premier course, expertly crafted by the lifelong educator **Justin Mitchel**. Known for his impactful teachings on the *Coding for Entrepreneurs* platform and YouTube, Justin guides you through the nuances of serverless application deployment with precision and clarity. This course is your gateway to mastering **Express.js** and **Node.js**, enabling you to construct robust REST APIs within a serverless framework. Embrace the freedom from server management as **AWS Lambda** and the **Serverless Framework** empower you to concentrate on crafting impeccable code. Elevated by **Neon's innovative Serverless Postgres**, our course redefines database integration, offering you an unparalleled learning experience supported by Neon's partnership and grant. This collaboration ensures your access to the forefront of technology and industry best practices. ## Course Highlights: - **Serverless Deployment Mastery**: Gain expert knowledge in deploying Express.js and Node.js applications via AWS Lambda, leveraging the efficiency of the Serverless Framework. - **Advanced Database Integration**: Attain proficiency in database setup, migrations, and seamless scaling with Neon Serverless Postgres. - **Automated Deployment**: Immerse yourself in the world of GitHub Actions and CI/CD tools for a streamlined, automated deployment process. - **Flexible Deployment Options**: Learn to adapt your deployment for various platforms like Vercel, broadening your application's reach and flexibility. - **Hands-On Learning**: Our focus is on practical application, equipping you with the skills to implement serverless solutions in real-world scenarios. This course is more than just learning; it's about applying knowledge through hands-on projects that prepare you for the serverless ecosystem. Discover the transformative power of serverless technology, which not only enhances scalability and efficiency but also allows developers to prioritize the essence of programming - the code itself. Ideal for those aiming to scale applications seamlessly, optimize database management, or refine deployment workflows, this course is your stepping stone to becoming a serverless development virtuoso. Join our transformative course today. Enroll now to unlock the vast possibilities of serverless technology with the expert guidance of **Justin Mitchel** and the innovative solutions from **Neon**.

## Unlocking Data Insights and Automation Embark on a transformative journey into the world of smarter web scraping, where Python's power meets the innovative capabilities of artificial intelligence. This course is designed to equip you with the knowledge and skills to navigate the digital landscape efficiently, turning web data into actionable insights and automating complex tasks with ease. ### What You'll Achieve: - **Sophisticated Data Extraction**: Elevate your scraping skills with advanced techniques for dynamic websites, utilizing tools like Selenium and BeautifulSoup for nuanced data retrieval. - **AI-Driven Analysis**: Infuse your projects with AI, employing Large Language Models to transform raw data into profound insights, elevating your analytical capabilities. - **Streamlined Workflows**: Unveil the secrets to automating mundane tasks, optimizing your processes, and dedicating more time to strategic analysis and innovation. - **Data Analysis Excellence**: Command the full cycle of data handling, from sophisticated extraction methods to in-depth analysis, mastering the art of turning extensive datasets into actionable intelligence. - **Innovative LLM Applications**: Harness the potential of emerging Large Language Models such as Ollama and LLama 2, integrating state-of-the-art AI tools for unparalleled depth in your web scraping endeavors. ### Course Highlights: - **Robust Foundation**: Regardless of your expertise level, begin with the essentials of Python and web scraping, ensuring a solid base for all learners. - **Real-World Application**: Through immersive projects that mirror actual industry challenges, you'll gain practical experience that's directly applicable outside the classroom. - **AI Integration**: Delve into the synergy between web scraping and artificial intelligence, mastering innovative tools that set the stage for future technological advancements. - **All-Encompassing Syllabus**: From initial setup to sophisticated data manipulation, our curriculum covers every angle, providing a holistic educational journey. ### Ideal Participants: - **Budding Data Scientists**: Embark on a data-centric career equipped with cutting-edge tools and methodologies. - **Visionary Entrepreneurs**: Utilize the power of web data to propel your business ideas and innovative ventures. - **Technology Aficionados**: Expand your repertoire with the latest in web scraping and AI, whether for professional development or personal passion. - **Eager Academics**: If your curiosity is piqued by the transformative potential of Python and AI in data insight, this course is tailored for you. ## Get Started Today: Join us in _Smarter Web Scraping with Python + AI_ and unlock the potential of web data. Whether you're looking to enhance your career, kickstart new projects, or simply indulge your curiosity, this course offers the tools, knowledge, and community support to help you achieve your goals. Enroll now and step into the future of web scraping and automation with Python and AI!

Learn how to build a Django-powered content engine that leverages AWS S3 for nearly unlimited amount of stored videos, images, files, and more. This content engine will also be extra private and secure thanks to Twingate's effective approach to sharing assets behind a next-generation private network. We start by automating the process of containerizing our Django application without writing a single Dockerfile. This means, we just focus on our code without learning Docker much like you would with a PaaS (e.g. Heroku). This is possible thanks to the great cloud-native tool known as Buildpacks and it's simple on GitHub Actions. With Kubernetes and Twingate, we will provide provide and secure _local_ access to _any_ resource we decide: Django project, databases, and much more depending on what containerized-app you want to use. Once this foundation is laid, we'll build out our Django project using cutting edge tools like HTMX and TailwindCSS to provide a fast, functional, and effective way to deliver a modern user experience without the overhead of writing JavaScript or CSS. The last major piece is getting large file uploads to work. This means we'll be learning all about how to use the official Amazon S3 package for Python known as Boto3. With Boto3, we will pre-sign files so we can download them, upload them, and delete them. In addition to Boto3, we write pure JavaScript to handle the uploading process (using functions like Fetch and XMLHttpRequests). This course is a juggernaut and we are excited to share it with you. And guess what? Thanks to Twingate, this entire course is already yours (just login and add it to your library). Are you ready to begin? Let's do this! ### References - Sign up for [Twingate](https://www.twingate.com/?utm_source=youtube&utm_medium=referral&utm_campaign=CodingEntrepreneurs) - Course GitHub & Code [here](https://github.com/codingforentrepreneurs/content-engine) - Django Auto Container [here](https://github.com/codingforentrepreneurs/django-auto-container) ### Helpful Resources - Django on Docker [guide](https://cfe.sh/blog/django-on-docker) - Docker & Docker Compose [tutorial series](https://cfe.sh/projects/docker-and-docker-compose): - Github Actions [guide](https://cfe.sh/blog/django-github-actions): - Django & Kubernetes project [code](https://github.com/codingforentrepreneurs/Django-Kubernetes)

Learn the fundamentals of the popular React.js framework Next.js by building a end-to-end URL shortening service. Every brand should have a URL shortening service for a few reasons: - Data ownership - Analytics tracking - Branding (e.g. no Bitly or other services) - Cost Savings URL shortening is the process of taking any URL and assigning a unique ID to it. This ID is often 2-8 letters and numbers to make the url short and consice such as `jref.io/abc13` or `jref.io/ad32Wa` and so on. This course will take you through each step of the way to help you build your own URL shortening service will introducing you to the speed of Next.js. deploying on Vercel, and leveraging serverless PostgresSQL with Neon. Here's what we'll cover: - React.js frontend and server-side rendering ➡️ Next.js is a React.js framework that handles front-end and backend - Vercel for Deployment ➡️ modern and easy deployments direct from GitHub/Bitbucket - Neon is Modern Serverless PostgreSQL ➡️ a fast Vercel-ready Edge-ready database with sub 40ms queries! - Edge functions for speed/performance ➡️ Server-side components that are fast and serverless! - DrizzleORM for handling SQL with JavaScript ➡️ Writing SQL can be tricky; Drizzle makes it easier - URL Shortening ➡️ A practical way to share and track links (this is what we build) - Tailwind CSS & Flowbite for the User Interface ➡️ Easily one of the best ways to style frontends - Users and sessions with custom built login, password hashing, registration, encrypted JWT sessions and more. ## Resources - [Code](https://github.com/codingforentrepreneurs/jref.io) - [Gists](https://gist.github.com/codingforentrepreneurs) - Sign up for free on [Neon](https://kirr.co/eu0b31) If you're interested in a Django version (albeit a bit older), consider watching [this course](https://www.codingforentrepreneurs.com/courses/try-django-110/).

If you're anything like me, you write a lot of Kubernetes manifest files and you end up storing them in Git. To convert these manifest files into actual resources, I'll often use GitHub Actions to apply changes along with `kubectl`. But what happens if I need to rollback to a previous version? What about if Github Actions has the incorrect permissions to provision my resources? Using CI/CD tools to provision Kubernetes can be an excellent way to automate the process but it often isn't enough. Enter AgroCD. Argo is installed directly in your Kubernetes Cluster so you can be rest assured that if your cluster is running, so is argo. Argo solves many challenges but the major ones are: - Automated syncing: Sync what's in Git with what needs to be in Kubernetes - Simple rollback: One-click rollback to previous manifests and/or resources tate - Easy come, easy go. Pick and choose different folders in your repos to monitor for syncing within ArgoCD In this course, you'll learn how to leverage the power of ArgoCD, an open-source, Kubernetes-native Continuous Delivery tool that automates application deployment, scaling, and management within Kubernetes clusters. ArgoCD follows the GitOps approach, treating Git as the single source of truth for declarative infrastructure and application configurations. This results in a version-controlled, reproducible, and automated deployment process, enabling efficient management and maintenance of applications at nearly any scale. Throughout the lessons, you'll gain hands-on experience with the following topics: - Setting up and provisioning a Kubernetes cluster with Terraform - Using `kubectl` to verify Kubernetes - Installing and configuring Nginx Ingress and Cert Manager - Creating and managing Cluster Issuers for SSL certificates and securing ArgoCD - Configuring and deploying ArgoCD with custom Ingress Manifests - Patching ArgoCD ConfigMap and managing deployments - Logging in to the ArgoCD web UI and managing applications - Deploying and managing applications in different environments (e.g., staging and production) - and more! By the end of this course, you'll have a solid understanding of ArgoCD's capabilities and how to harness its power to streamline application deployments, reduce human error, and ensure that your applications are always running with the intended configurations in Kubernetes environments. ## Recommended Prerequisites - Watch [Terraforming Kubernetes on Linode](https://www.codingforentrepreneurs.com/courses/terraforming-kubernetes-on-linode/) or have experience with Kubernetes clusters - [Git](https://git-scm.com/downloads) installed - [Terraform](https://developer.hashicorp.com/terraform/downloads) installed - [Kubectl](https://kubernetes.io/docs/tasks/tools/) installed ## Resources - [Main Code Repo](https://github.com/codingforentrepreneurs/terraforming-kubernetes-argocd) - [ArgoCD Code Examples](https://github.com/codingforentrepreneurs/tko-argocd-examples) - [K8S Service Account Blog Post](https://www.codingforentrepreneurs.com/blog/kubernetes-rbac-service-account-github-actions/) - [Rapid-Fire Terraforming Kubernetes Repo](https://github.com/codingforentrepreneurs/terraforming-kubernetes-rapid) - [Kubernetes & Postgres Repo](https://github.com/codingforentrepreneurs/kubernetes-postgres)

Learn to build a modern web application to sell one-off digital products using Python, Django, Serverless Postgres, TailwindCSS, and the Stripe API. A long term goal of this course would be to set a very practical foundation for selling products online so you can build traction for your project. Once you have traction you can continuously improve until you build a sustainable business on your own. **Topics** - Production database integration with Neon’s Serverless Postgres - Branched database versions for dev, staging, and prod - Sell, upload, and download digital files with Object Storage - Purchase-protected Downloads - Product Pages with TailwindCSS and Flowbite - Using Environment Variables - Containerize Django with Docker - Stripe API and Checkout Integration - and much more! **Prerequisites** - Python experience with [30 Days of Python](https://www.codingforentrepreneurs.com/courses/30-days-python-38/) or similar - Django experience with [Try Django](https://www.codingforentrepreneurs.com/courses/try-django-3-2/) or similar - Basic understanding of HTML and CSS **Required Software** - [Python 3.10](https://www.python.org/downloads/) or newer - [Node.js 18.15 LTS](https://nodejs.org/) or newer (For Tailwind.CSS) - [Git](https://git-scm.com/) - (Optional) [Docker](https://www.docker.com/get-started/) **References** - [Github Code](https://github.com/codingforentrepreneurs/micro-ecommerce) - [Neon](http://neon.tech) - [Docker Image for Micro eCommerce](https://hub.docker.com/r/codingforentrepreneurs/micro-ecommerce) - [Stripe Products API Reference](https://stripe.com/docs/api/products?lang=python): - [Stripe Product and Price Management Examples](https://stripe.com/docs/products-prices/manage-prices?dashboard-or-api=api#create-product) - [Stripe Checkout page] (https://stripe.com/docs/checkout/quickstart) **[Live Demo](https://micro-ecommerce.demo.cfe.sh/)**

This course is a practical implementation of enabling others to leverage your Kubernetes resources with a practical hands-on example by giving GitHub Actions the correct permissions to provision a PostgreSQL database on Kubernetes. Yup, you read that right PostgresSQL on Kubernetes. That's the hidden gem in this course -- learning how to deploy PostgreSQL to Kubernetes. To do this, we'll be covering the following topics: - Kubernetes Service Accounts - Kubernetes Roles & Role Bindings - Config files for Service Accounts - StatefulSets and Persistent Volume claims - Automating updates via GitHub Actions - And more! Kubernetes is an incredible platform and this course is meant to help you dive deeper into using it and get better at deploying your software in the process! ## Prerequisites - Watch [Terraforming Kubernetes on Linode](https://www.codingforentrepreneurs.com/courses/terraforming-kubernetes-on-linode/) or have experience with Kubernetes clusters - [Git](https://git-scm.com/downloads) installed - [Terraform](https://developer.hashicorp.com/terraform/downloads) installed - [Kubectl](https://kubernetes.io/docs/tasks/tools/) installed ## Resources - [K8S Service Account Blog Post](https://www.codingforentrepreneurs.com/blog/kubernetes-rbac-service-account-github-actions/) - [Rapid-Fire Terraforming Kubernetes Repo](https://github.com/codingforentrepreneurs/terraforming-kubernetes-rapid) - [Kubernetes & Postgres Repo](https://github.com/codingforentrepreneurs/kubernetes-postgres)

Deploy a Serverless Python Application with Docker Containers and Google Cloud Run. Running our apps on managed serverless architectures allows us to focus on our code and deploy more without worrying about the underlying infrastructure. What's better, our serverless applications only cost us money when they're used this is because serverless apps can scale to 0 running instances or scale up as needed. Serverless is great for testing all kinds of app ideas as well as testing various stages of a stable app. Cloud Run is a managed service that unlocks serverless apps for your projects on Google Cloud. It's how we run this website exactly. Cloud Run is a managed Knative offering that runs on Kubernetes so if you're interested in deploying a self-managed Knative service, consider watching [Try Knative](https://www.codingforentrepreneurs.com/courses/try-knative/). Here's what we're going to learn in this course: - Creating a basic `FastAPI` web app (in Python) - Implement `python-decouple` to manage environment variables in FastAPI - Writing a basic automated test to ensure our app is working as needed - Prepare and learn about a `Dockerfile` before building a container - Building a `Docker container` locally - Running a custom Docker image (container) locally - Push our code to GitHub - Leverage `GitHub Actions` to perform CI/CD workflows - Using Github Actions to build and push our Docker container to Google Cloud - Use Google Cloud Secrets manager within our Python app - Update Secrets in Github Actions as needed - Deploy our app continuously on Google Cloud Run ## Resources - [Google Cloud CLI Install Guide](https://www.codingforentrepreneurs.com/blog/google-cloud-cli-and-sdk-setup/) - [Github Code](https://github.com/codingforentrepreneurs/Serverless-Container-Based-Python-App-on-Google-Cloud-Run) - [Using Google Secrets Manager with Python Decouple and GitHub Actions](https://www.codingforentrepreneurs.com/blog/google-secrets-python-decouple-github-actions/) - [Try Knative](https://www.codingforentrepreneurs.com/courses/try-knative/) - [Previous version of this course](https://www.codingforentrepreneurs.com/courses/serverless-container-python-app/)

Learn how to create a modern, inline, typeahead HTML input using Vue. With the huge influx of AI-based generated text, it's a perfect time to learn how to help users decide what their intent is while typing. If you're familiar with "autocomplete" or "typeahead" methods, this is very similar to that but with the results inline with a normal HTML `textarea`. This series is inspired, in part, by VSCode but designed to work within your web apps. The goal of this series is two fold: - Learn more about Vue.js and the Composition API - Build the foundation of a practical HTML element we can use in future AI-based projects. ## Demo  ## Resources - [Django x Vue.js](https://www.codingforentrepreneurs.com/courses/django-vuejs-3/) - [Github Code](https://github.com/codingforentrepreneurs/predict-input)

In this course, we're going to deploy serverless containerized applications on Kubernetes by using Knative. Knative is a Kubernetes-based platform for running serverless. Serverless means you can scale your application to 0 running instances but those instances to quickly scale up to N number of instances within a few seconds. Scaling to 0 is fantastic because it allows Kubernetes and Knative to reallocate resources as needed. If you couple that with an LKE autoscaling feature (which will add compute nodes to your cluster), you can have a very robust system with not much financially invested. The investment for Knative comes in the form of the learning curve to get it running and unlocking continuous delivery/deployment. This article and the Try Knative course are here to help you get started using Knative in production using a managed Kubernetes cluster on Linode's LKE service. Here's what we're going to cover in this article and the course: - Using Terraform to create our Kubernetes Cluster on Linode - Install Knative and Istio - Configure a Knative Service and Domain Mapping - Install cert-manager for auto-provisioning of HTTPs certificates - Configure an Istio Gateway for HTTP and HTTPS requests (ingress) - Implement Knative service environment variables (both ConfigMap and Secrets) In this series, we'll learn how to install Knative to a Kubernetes cluster and deploy a containerized application! ## Prerequisites - Watch [Terraforming Kubernetes on Linode](https://www.codingforentrepreneurs.com/courses/terraforming-kubernetes-on-linode/) or have experience with Kubernetes clusters - [Git](https://git-scm.com/downloads) installed - [Terraform](https://developer.hashicorp.com/terraform/downloads) installed - [Kubectl](https://kubernetes.io/docs/tasks/tools/) installed ## References - [Code on Github](https://github.com/codingforentrepreneurs/try-knative) - [Blog Post](https://www.codingforentrepreneurs.com/blog/try-knative-on-lke/) - [Linode $100 Credit](https://linode.com/cfe) - Experience the [Live Demo](https://cfe-nginx.demo.cfe.sh/) or [Watch the Demo](https://www.codingforentrepreneurs.com/courses/try-knative/lessons/demo-end6/) being created

Learn how to integrate Tailwind CSS into your Django projects. Tailwind is a paradigm shift for how you'll use CSS in your _all_ of your web applications and Django projects. Instead of using classes like `btn-primary` you'll use a list of more robust classes to describe how you want your element to render. Such as: - `bg-blue-500` (the background color) - `text-white` (the text color) - `rounded-lg` The border radius - `hover:bg-blue-800` The background color when someone _hovers_ on this element - `px-5` The horizontal padding on the left or the right of the contents And so much more. Writing CSS classes like this is almost _too_ verbose since it seems to violate DRY but it does not. Instead, this verboseness unlocks a clarity in how you document your CSS classes and how things are rendered. It took me a long time to adopt Tailwind because of this verboseness but once I did, I have never looked back. Tailwind is incredible. In this course, we will learn how to setup Django project to leverage Tailwind.css from scratch. ### Resources - [Code on Github](https://github.com/codingforentrepreneurs/django-tailwindcss/) - [Tailwind.css Docs](https://tailwindcss.com/docs/installation) - [Django Static Files Docs](https://docs.djangoproject.com/en/4.0/howto/static-files/) - [Live Demo](https://django-tailwindcss.demo.cfe.sh/)

In this course, you will learn how to integrate a Django project with the popular JavaScript user interface library Vue.js. We'll cover the following: - Develop Django & Vue.js simultaneously - Limit third-party package usage (no Python-based JavaScript compilers here) - Leverage Django Templates with Vue.js - Implement Cross Site Request Forgery (csrf) safely - Dynamically load file paths with Pathlib - Use custom Django Template Context Processors - CRUD from Vue.js to Django without additional API frameworks (such as Django Rest Framework) - Use Vite to build and compile our Vue.js application - And more The goal of this course is to build a practical and forward-thinking approach to integrate nearly _any_ JavaScript library with your Django project. While you can take Vue.js and Django many places, having this type of integration will help you get there. ### Recommended Experience - A [Try Django](/topics/try-django) course or [Your First Django project](/courses/your-first-django-project/) or similar - JavaScript fundamentals ### References - [Code on Github](https://github.com/codingforentrepreneurs/django-vuejs) - [Vue.js](https://vuejs.org/) - [Vite](https://vitejs.dev/) (for compiling Vue.js) - [Create a Predict Input with Vue](https://www.codingforentrepreneurs.com/courses/predict-input/) - [Django Static Files Docs](https://docs.djangoproject.com/en/4.0/howto/static-files/) - [Live Demo](https://django-vue-3.demo.cfe.sh/)

What if starting a remote virtual machine instance was as simple as changing a number on a document and running a command? That is how simple terraform can be and why it's so powerful. Using documents to change what server we need running is a feature of Infrastructure as Code and can be a paradigm shift for many developers since it's so simple yet effective. One of the biggest advantages of IaC and terraform: version control and CI/CD pipeline automation. Terraform will turn on (and off) the servers we need. Kubernetes will manage how we allocate the resources on those servers to run the applications we want and need. The pair is a juggernaut of automation. This post will teach you exactly what to do to use them both. _Want a minimal and rapid-fire version of this post? Check out [this repo](https://github.com/codingforentrepreneurs/terraforming-kubernetes-rapid)._ __Resources__ - [Blog Post](https://www.codingforentrepreneurs.com/blog/terraforming-kubernetes-on-linode/) - [Github Repo](https://github.com/codingforentrepreneurs/terraforming-kubernetes) - Recommended Course: [Docker & Docker Compose](https://www.codingforentrepreneurs.com/courses/docker-and-docker-compose/) - [Terraform Install Guide](https://developer.hashicorp.com/terraform/downloads) - [Kubernetes Command Line Tool Install Guide](https://kubernetes.io/docs/tasks/tools/)

In this course, we'll be setting up a Node.js application running Express.js and HarperDB on Ubuntu on Linode. You can use any Ubuntu LTS from version 18.04 and, but we'll be using Ubuntu 20.04 LTS for this series. The goal of this is to introduce you to leveraging the flexible HarperDB database along with a minimal Express.js application. The HarperDB instance will be running on Linode we'll our Express.js web server will be running just on our local machine. If you like this one, let me know in the comments so we can do more Node.js/Express/HarperDB in the future. **References** - [Code](https://github.com/codingforentrepreneurs/expressjs-harperdb) - [Blog Post](https://www.codingforentrepreneurs.com/blog/haperdb-expressjs-ubunutu-linode/) - [Linode](https://linode.com/cfe) - [HarperDB](https://harperdb.io)

Python is one of the most widely used programming languages in the world. In this course, I'll show you exactly how to set it up regardless of what operating system your computer is. The setup process can be very simple (such as download Python and run it) but it can also start to get rather complex. My goal is to break apart this complexity and put it into manageable chunks that allow you to actually have a solid foundation of how to install Python and actually use it in real projects. This course is the result of nearly a decade of teaching students around the world how to best setup Python environments and develop applications and automations with Python. Based on feedback, this course will continue to be updated and upgraded to ensure you have the best possible way to set up your Python development environment at your fingertips. Supported Platforms: - macOS - Windows (XP or Later) - Linux

Build a recommendation engine using Django & a Machine Learning technique called _Collaborative Filtering_. A project like this is really a collection of 3 parts: - Web Process: Setup up Django to collect user's interest and provide recommendations once available. - Machine Learning Pipeline: Extract data from Django, transform it, and train a Collaborative Filtering model. - Worker Process: This is the glue. We'll use Celery to schedule/run the trained model predictions and update data for Django-related user recommendations. **Recommended Experience** - Python 3.6+ (such as [30 Days of Python](https://www.codingforentrepreneurs.com/courses/30-days-python-38/)) - Django 3.2+ (such as [Your First Django Web Project](https://www.codingforentrepreneurs.com/courses/your-first-django-project/) or [Try Django 3.2](https://www.codingforentrepreneurs.com/courses/try-django-3-2/)) - Celery with Django (such as [Time & Tasks 2](https://www.codingforentrepreneurs.com/courses/time-tasks-2/) or [this blog post](https://www.codingforentrepreneurs.com/blog/celery-redis-django/)) **Optional but helpful** - [Try Pandas](https://www.codingforentrepreneurs.com/courses/try-pandas/) - [Try Keras](https://www.codingforentrepreneurs.com/courses/try-keras/) - [The Hello World of Machine Learning](https://www.codingforentrepreneurs.com/courses/hello-world-machine-learning/) **Resources** - [Code on Github](https://github.com/codingforentrepreneurs/recommender) - [Live demo with limited features](http://recommender.demo.cfe.sh)

Building a web application has never been easier thanks to open source. In this course, we're going to go step-by-step building a Django web application. If you've never used Django before, this is the course for you. Django is one of the most popular web frameworks written in the Python programming language. Django and Python are both open source and free to use commercially. This means you don't have to pay a dime to create amazing software and impact people all around the world. Django powers many websites in the world including: Instagram, Pinterest, NASA, Baserow, this website, and so many others. The goal of this course to teach you the fundamentals of Django while also creating a very practical project. Building something real is important because it gives you the context of how, when, and where to use a lot of Django's great features. Django sits right in the middle of creating an app from scratch and using something like Wordpress. This means we have a lot of features we *could* implement along with a lot of features that *just work* by default. This makes Django incredibly flexible so that we can go far beyond what a blogging platform offers while being faster than starting from absolute 0. For our User Interface, we're going to learn the fundamentals of Bootstrap. Bootstrap makes our Django project look far more professional in very little time. Not only that, we'll also have a much better user experience by leveraging many of Bootstrap's built-in features. If we were building a house, Django would be the plumbing, the walls, and electricity while Bootstrap is the interior decorator. Here's a few things we'll cover: - Django version 4.1 (or even 2.2+) - Python version 3.10 (or 3.8+) - Bootstrap 5.2+ - Collecting data from users - Rendering HTML templates and documents - Password-protected pages & user-type permissions - Modeling data in Django as it relates to a spreadsheet - Dynamically display content based on stored database data - Much more ## References & Help - [Code](https://github.com/codingforentrepreneurs/Your-First-Django-Project) - [Community Discussions](https://github.com/codingforentrepreneurs/Your-First-Django-Project/discussions) - [Live Demo](https://your-first-django-project.demo.cfe.sh/)

Learn the fundamental techniques for analyzing time-series data with Python, MongoDB, PyMongo, Pandas, & Matplotlib *References* - [Blog post](https://codingforentrepreneurs.com/blog/time-series-with-python-mongodb-guide/) - [Code](https://github.com/codingforentrepreneurs/time-series-mongodb-pymongo) *Prerequisites* - Python 3.8+ Installed - Docker Desktop Installed (for local MongoDB instance) - Terminal or PowerShell experience

This series is all about sustainably deploying Django into production on virtual machines we control. Production can get rather messy so we're going to limit the amount of manual work and opt for as much automation work as possible. To do this, we're going to be focusing on these core areas: - CI / CD with Git, GitHub, and GitHub Actions - Django on Docker & DockerHub (as well as using WatchTower) - Load Balancing with NGINX - Production Databases with managed MySQL by Linode - Local/Development use of production-like Databases - Terraform to provision Infrastructure on Linode - Ansible to configure infrastructure on Linode (in tandem with Terraform) - Django-based File Uploads & Django Static Files on Linode Object Storage This course focuses on getting Django into production, but most of what we cover can be adapted for many other technologies as well. The reason? Our Django project will run through Docker with Docker containers. Docker is a massive key to putting many, many different applications in production. It's a great tool, and we'll use it as the backbone that Django sits on. Before all the branded names for the tech stack start to scare you off, I want you to remember that so much of what we'll do here is writing a bunch of documents with a specific syntax and goal. Just because it's called Docker or Python or Terraform, they are still all just documents that describe... something. With that in mind, I want you to think of the above list like this: - GitHub: a place to store our code, almost like a folder on your computer. - GitHub Actions: an app that automatically starts a chain of events related to testing (verifying the document does what the writer intended), building (let's put a stamp on this code and say that this version is done), and running our code in production (find the code that should run the best, is ready, and let's and run that) - Django: A bunch of python documents to handle the logic of an HTML website, store data, and handle user data. - Docker: essentially a document that we write to describe, on the operating system level, how our Django app needs to run. Docker itself does more than this, but we mostly work on the document part (a Dockerfile). - Load Balancing with NGINX: a document that we write to tell nginx to send incoming website traffic to the different servers running our Docker-based Django app. Managed databases: a powerful spreadsheet that you never need to open or touch (thanks to Linode & Django). - Terraform: a document describing all of the products and services we need from Linode (like virtual machines) to run our Django project. - Ansible: a few documents we use to tell all of the products and services what software our Django project needs is needed to run. - Linode Object Storage: a file system (sort of) that allows us to store files that don't change very often like images and videos as well as other documents like CSS and some kinds of JavaScript. If you read the above and thought to yourself, "well that's overly simplistic" -- you're right! If you read the above and thought to yourself, "oh no, what am I doing with my life" -- you're right! The nice thing about what we're doing here is taking the guesswork out of making this list work, work correctly, and work reliably. Most of the technology we will cover here has been well established and will likely remain unchanged for the foreseeable future. ### References - [Github Repo](https://github.com/codingforentrepreneurs/deploy-django-linode-mysql)

Learn how to build REST APIs with Django and the Django Rest Framework. We will also build a Python client along side of our Django project so we can actually use our REST API in a practical hands-on example. Web APIs, also know as REST APIs, are how applications can communicate with each other. Essentially, we'll design a standard way to enable our Django project (through Django REST Framework) to communicate with nearly *anything else* such as: - React.js/Vue/Angular apps - Phone & Table Native Apps (like iOS or Andriod) - Django to Node.js communication or Django to FastAPI, or Django to Ruby on Rails ## References - [Code](https://github.com/codingforentrepreneurs/Django-Rest-Framework-Tutorial) - [Django Rest Framework Docs](https://www.django-rest-framework.org/) - [Django Docs](https://www.djangoproject.com) We've partnered with [Algolia](https://www.algolia.com/) to bring you this series and even our website search!

Learn how to deploy a production-ready Django application into a Kubernetes cluster. Kubernetes is a tool to manage containers. This type of management is called orchestration because it does more than just manage the containers such as it will scale up and scale down resources as needed (among many other things). Since Kubernetes is a massive tool, we're going to be covering a practical implementation using a Docker-based Django application. Django is a way to build web applications rapidly using Python. There are many ways to get Django into production so the question is why use K8S at all? There's many reasons we'll cover throughout this series but here are a few: - Gracefully deploy Docker-based Django projects - Scale up (or scale down) your web apps with ease - Use a few or a lot of microservices internally or externally - Self-heal when services go down - Simplify app deployment (after initial configuration) - Streamline your backend Infrastructure (provision virtual machines and let k8s do the rest) Kubernetes can do *a lot* which makes it a great tool to learn but also a daunting one at that. To make it more approachable here's what we'll be doing: - Start a Python Virtual Environment - Create a bare bones production-ready Django project - Create a Dockerfile to describe our environment (much like [this blog post](https://www.codingforentrepreneurs.com/blog/django-on-docker)) - Use a managed Database service from DitgitalOcean - Install Kubernetes locally - Start a Kubernetes Cluster on DigitalOcean - Provision a Deployment and Service for our Django project - Implement Github Action Workflows to automate future deployments ### References - [Django on Docker](https://www.codingforentrepreneurs.com/blog/django-on-docker) guide - [Docker & Docker Compose](https://www.codingforentrepreneurs.com/projects/docker-and-docker-compose) tutorial series - [Github Actions](https://www.codingforentrepreneurs.com/blog/django-github-actions) guide - [DigitalOcean $100 credit](https://do.co/cfe-sh) for new accounts - [Code](https://github.com/codingforentrepreneurs/Django-Kubernetes) We have partnered with [DigitalOcean](https://do.co/cfe-sh) to bring you this series. Sign up for an [account](https://do.co/cfe-sh) when you're ready to get started with this series.

Create a Video Membership app using FastAPI & NoSQL. In this series, we're going to explore building a membership application using FastAPI and a managed Cassandra database called [AstraDB](https://dtsx.io/3hO4c4w). In this one, we'll learn how to implement a number of key features in building a video membership site including: - Creating Users (with custom fields) from scratch - Saving Secure, Hashed, Passwords - Authentication - Video Analytics - And much more #### References: - [Github Repo](https://github.com/codingforentrepreneurs/video-membership)