Spring Framework DevOps on AWS

Use the Spring environment interface to access properties from the classpath testing.properties and inject them into a configuration bean, and override with environment variables, illustrating precedence across environments.

Explore managing multiple property files in spring by using the property source annotation with a list and the nested property sources approach, enabling functional file separation and versatile configuration.

Activate Spring profiles to control which beans load into the context, and set active profiles for dev, qa, and production data sources across environments.

Learn how Spring profiles select between dev, QA, and prod data sources by annotating implementations as components and activating a profile to wire the appropriate bean at runtime.

Set an active Spring profile in unit tests to wire the correct data source beans. Learn how dev, qa, prod, and default profiles affect bean wiring.

Set and override Spring Boot active profiles at runtime using application properties, command line parameters, and environment variables, and observe how different beans wire into the context across environments.

Explore how Spring Boot profile properties wire into beans via application-default.properties and profile-specific files. See constructor injection wire the profile value and reveal the bean lifecycle under the default profile.

Review how to create Spring Boot properties files for dev, QA, and prod, wire profile messages into beans, and explore non-profile beans and the 1-to-1 profile-property relationship.

Learn how Spring Boot configurations use YAML alongside properties, compare their benefits, and apply active profiles in YAML to manage dev settings within a unified Spring context.

Set up a local MySQL database for development and QA, use H2 in-memory for QA testing, and migrate to AWS RDS MySQL for production across three data sources.

Set up a local MySQL database by logging in from the command line as root and creating a database named Spring Guru for use with Spring Boot.

Configure a MySQL data source in Spring Boot by enabling the QA profile and adding datasource properties in application-qa.properties. Spring auto-configures the data source and uses Hibernate ddl-auto update.

Implement a Spring bootstrap loader to load test data on startup and prevent duplicates when using MySQL; trigger via a context refresh event and check repository content.

learn how to create a restricted service account for a MySQL database to enforce minimal privileges, restricting schema changes and enabling basic crud operations for a spring application.

Learn to encrypt properties in a Spring Boot app using the Jssip (Java Simplified Encryption) library, add the Maven dependency, and leverage the ENC tag to decrypt properties at runtime.

Create a second QA two testing environment by provisioning a MySQL database named QA two, adding an encrypted service account, and configuring spring profiles to switch between three databases.

Learn how to configure a MySQL data source in a Spring app using sha two profiles, create a user, encrypt properties, and run across multiple environments.

Provision a red hat server in the cloud, install jenkins for continuous integration, and configure nexus with docker for an internal maven repository and friendly URLs.

Explore Amazon AWS fundamentals, including EC2 Linux instances, Elastic Beanstalk, RDS MySQL, and Route 53 DNS, and learn to provision a server for Jenkins CI with a domain name.

Provision an AWS server by selecting an AMI, launching a Red Hat Enterprise Linux free-tier instance, and configuring SSH access and ports 80 and 8080 to run Jenkins.

install Oracle JDK and Jenkins on a Red Hat server provisioned in AWS, configure Java with alternatives, set up Jenkins via yum, and complete initial admin setup to start building.

Install Apache httpd as a reverse proxy on port 80 to Jenkins on 8080, editing httpd.conf and restarting httpd. Bind Jenkins to localhost and adjust security settings on hardened Linux.

Learn to generate and deploy ssh keys (rsa) for Jenkins to securely authenticate with GitHub, enabling encrypted server communication without passwords.

Configure GitHub deploy keys to grant read access, and connect Jenkins via ssh keys. Learn to locate, copy, and add the public key to GitHub.

Install git on a Red Hat Jenkins server using yum, enabling Jenkins to check out from GitHub; the process involves sudo, dependency handling, and verifying git version (1.8).

Configure Maven as a build tool in Jenkins by adding it in global tool configuration, enabling automatic installation from Apache with Maven 3.3.9, or the latest version.

Configure a Jenkins freestyle build for a Spring Boot project, set up GitHub integration (SSH/HTTPS credentials, polling), and run Maven goals: clean, package, install, with integration tests.

Test a Jenkins build by changing code in IntelliJ, committing to GitHub, and confirming Jenkins triggers the build via polling or a webhook.

Set up a GitHub webhook to trigger Jenkins builds on every commit, delivering immediate feedback and faster, automated builds.

Conclude the module by configuring a Jenkins server for a professional, scalable CI workflow, using SSH keys, Apache fronting, and webhooks to support large teams with seamless builds.

Provision a small cloud server with redhat or centos, install docker, and deploy Artifactory with docker to support a memory-constrained Jenkins setup on AWS.

Discover how Docker uses Linux containers to isolate apps and MySQL databases, replacing virtual machines with lightweight images and containers managed by a daemon for portable development.

Docker splits into enterprise edition and community edition, where enterprise provides a paid subscription, certified infrastructure, and backported patches, while community edition stays free with edge releases and quarterly releases.

Install Docker on a Linux image using yum, configure the Docker repo, install and start the Docker engine as a service, and verify with a hello world container.

This assignment review demonstrates setting up Artifactory behind Apache with a virtual host on port 80, proxied to 8081, using a subdomain configured in DNS and the Artifactory context.

Set up Artifactory for a local build environment, enable artifact hosting and local mirroring of public Maven repositories, and generate a settings.xml with encrypted credentials.

Set up Artifactory to host internal artifacts, cache external dependencies, and strengthen CI while supporting compliance with SOX, PCI, SAS 70 and secure open source software management.

Simulate a production deployment by provisioning a cloud database server with a dockerized MySQL, configuring credentials and a production service account, then deploy a Spring application to an app server.

Provision a database server using docker on a new linux instance with a public IP, configure port 3306, and deploy a MySQL image with ports, storage, and a user parameter.

Configure a production data source by creating a MySQL database and a restricted service account for a Spring Boot app in a Docker Linux environment, and connect with those credentials.

Examine production data source security by using a limited-privilege service account for CRUD on the schema, avoiding Hibernate-managed schema changes in enterprise environments.

Provision an application server on red hat enterprise linux or centos, run yum update to update packages, and prepare the environment for spring boot as the next module builds.

Install OpenJDK on Linux with yum update and yum install java-1.8.0-openjdk to run Spring Boot, preferring OpenJDK over Oracle to avoid licensing hassles.

Install wget on the Linux server and fetch the Spring Boot Uber jar from Artifactory using wget, noting that the Uber jar is self-contained.

Run a Spring Boot jar in the cloud by overriding properties with environment variables, connecting to a MySQL database, and deploying an unmodified artifact from Artifactory in a Linux environment.

Encrypt the database password property, redeploy with the encrypted value in an environment variable, and verify the app connects to the database, underscoring enterprise need to avoid free text passwords.

Conclude by deploying a production database with Docker and a Spring Boot executable jar, compare embedded Tomcat to war deployments, and emphasize Docker or executable jar as future standards.

Discover how to provision an Amazon RDS MySQL instance, move from MySQL in Docker to the new Amazon RDS database, and reconfigure the app to connect to it.

Set up a new Spring Boot active profile to connect to local and RDS MySQL databases, configure the JDBC URL, endpoint, and port 3306, and test the connection.