1. Head over to the Firebase Console.
2. Click on "Add project" and just follow the steps to create a new Firebase project.
3. Once your project is ready, go to the project settings by clicking the gear icon next to "Project Overview."

1. Click on the web icon (</>) to register a new web app.
2. Follow the instructions to register and configure the app. Firebase will give you a configuration object; keep this info handy for later.

1. Open the terminal in your Angular project directory.
2. Install Firebase and AngularFire by running:
   ```sh
   npm install firebase @angular/fire
   ```

1. Open src/environments/environment.ts and add the Firebase configuration you got from Step 2:
   ```typescript
   export const environment = {
   production: false,
   firebaseConfig: {
   apiKey: "your-api-key",
   authDomain: "your-auth-domain",
   projectId: "your-project-id",
   storageBucket: "your-storage-bucket",
   messagingSenderId: "your-messaging-sender-id",
   appId: "your-app-id",
   measurementId: "your-measurement-id"
   }
   };
   ```

2. Make sure to add the same configuration to src/environments/environment.prod.ts if you plan to deploy the app.

1. Open src/app/app.module.ts.
2. Import AngularFireModule and environment:
   ```typescript
   import { AngularFireModule } from '@angular/fire';
   import { environment } from '../environments/environment';
   ```
3. Initialize Firebase:
   ```typescript
   @NgModule({
   declarations: [
   AppComponent,
   // other components
   ],
   imports: [
   BrowserModule,
   AngularFireModule.initializeApp(environment.firebaseConfig),
   // other modules
   ],
   providers: [],
   bootstrap: [AppComponent]
   })
   export class AppModule { }
   ```

1. Depending on the Firebase services you need (e.g., Firestore, Authentication, Storage), install and configure additional modules:
   ```sh
   npm install @angular/fire/firestore @angular/fire/auth @angular/fire/storage
   ```

2. For each service, import it into app.module.ts:
   ```typescript
   import { AngularFirestoreModule } from '@angular/fire/firestore';
   import { AngularFireAuthModule } from '@angular/fire/auth';
   import { AngularFireStorageModule } from '@angular/fire/storage';

   @NgModule({
   imports: [
   AngularFireModule.initializeApp(environment.firebaseConfig),
   AngularFirestoreModule,
   AngularFireAuthModule,
   AngularFireStorageModule,
   // other modules
   ],
   })
   export class AppModule { }
   ```

1. Create and use services to encapsulate Firebase logic:

• Generate a service:
  ```sh
  ng generate service services/firebase
  ```

• For example, for Firestore:
  ```typescript
  import { Injectable } from '@angular/core';
  import { AngularFirestore } from '@angular/fire/firestore';

  @Injectable({
  providedIn: 'root'
  })
  export class FirebaseService {
  constructor(private firestore: AngularFirestore) { }
  
  getCollection(collection: string) {
  return this.firestore.collection(collection).snapshotChanges();
  }
  
  // other Firestore operations
  }
  ```

1. Inject the Firebase service into a component:
   ```typescript
   import { Component, OnInit } from '@angular/core';
   import { FirebaseService } from './services/firebase.service';

   @Component({
   selector: 'app-root',
   templateUrl: './app.component.html',
   styleUrls: ['./app.component.css']
   })
   export class AppComponent implements OnInit {
   constructor(private firebaseService: FirebaseService) {}

   ngOnInit() {
   this.firebaseService.getCollection('exampleCollection').subscribe(data => {
   console.log(data);
   });
   }
   }
   ```

2. Adjust the component template and styles as needed to use the fetched data.

Each step integrates specific parts of Firebase with the Angular application, providing a structured approach to set up and utilize Firebase services fully.