Skip to main content

Check out Port for yourself 

Getting Started with Port

⏱️
Duration45 minutes
📚
Modules3
🎯
TrackDeveloper

Prerequisites​

Before you begin

This course is designed for developers and technical team members who want to create and manage a software catalog. While no prior experience with Port is required, the following will help you get the most out of this course:

Required Prerequisites​

  • Access to a Port account (you can sign up for free)
  • Basic understanding of software development concepts
  • Familiarity with web browsers and modern development tools
  • Basic knowledge of YAML/JSON (for blueprint definitions)
  • Understanding of software architecture concepts
  • Experience with developer tools and APIs

Helpful but Optional​

  • Experience with software cataloging tools
  • Knowledge of microservices architecture
  • Familiarity with Git and version control

Course Overview​

Welcome to your journey with Port! This course will guide you through the essential concepts and practical steps to get started with Port's software catalog platform. By the end of this course, you'll have a solid foundation and be ready to build your first software catalog.

What you'll learn
  • Understanding Port's core concepts and terminology
  • Setting up your first software catalog
  • Creating and managing blueprints
  • Adding your first entities
  • Basic catalog navigation and search
  • Best practices for getting started

Course Modules​

Module 1: Introduction to Port (10 minutes)​

Core Concepts

Port is a developer portal that helps you create a comprehensive software catalog. Think of it as a single source of truth for all your software assets, services, and resources.

What is a Software Catalog?​

A software catalog is a centralized inventory of all your software assets, including:

  • Microservices and applications
  • Infrastructure components
  • APIs and endpoints
  • Documentation and runbooks
  • Team ownership and responsibilities

Why Use Port?​

Port provides several key benefits:

  1. Centralized Knowledge: All your software assets in one place
  2. Improved Visibility: Clear understanding of your software landscape
  3. Better Collaboration: Shared context for all team members
  4. Automated Updates: Keep your catalog in sync with your actual infrastructure
  5. Developer Experience: Self-service access to critical information

Key Use Cases​

Port helps you:

  • Onboard new team members faster
  • Track service dependencies
  • Manage technical documentation
  • Monitor service health
  • Enforce best practices
  • Automate compliance reporting

Port's Architecture​

Port's architecture consists of three main components:

  1. Blueprints: Define the structure of your catalog items
  2. Entities: The actual catalog items (services, applications, etc.)
  3. Relationships: Define how different entities are connected

Module 2: Setting Up Your Environment (15 minutes)​

Prerequisites

Before starting this module, ensure you have:

  • Access to a Port account
  • Required permissions in your organization
  • Basic understanding of YAML/JSON

Creating Your Port Account​

  1. Visit app.getport.io/signup
  2. Choose your authentication method (GitHub, Google, or email)
  3. Complete the onboarding process
  4. Set up your organization profile

Understanding the Port Interface​

The Port interface consists of several key areas:

  • Dashboard: Overview of your catalog
  • Blueprints: Define and manage your catalog structure
  • Entities: View and manage your catalog items
  • Settings: Configure your workspace
  • API: Access Port programmatically

Configuring Your Workspace​

  1. Organization Settings

    • Set your organization name and logo
    • Configure authentication methods
    • Set up team roles and permissions

  2. Workspace Configuration

    • Choose your default view
    • Set up notifications
    • Configure integrations

  3. Initial Setup

    • Create your first blueprint
    • Set up basic entity types
    • Configure default views

Setting Up Initial Integrations​

Port can integrate with various tools:

  • Git Providers: GitHub, GitLab, Bitbucket
  • CI/CD Tools: Jenkins, GitHub Actions, GitLab CI
  • Cloud Providers: AWS, GCP, Azure
  • Monitoring Tools: Datadog, New Relic, Grafana

Module 3: Building Your First Catalog (20 minutes)​

Best Practice

Start small and iterate! Begin with a few key blueprints and entities, then expand your catalog as you become more comfortable with Port's features.

Creating Your First Blueprint​

  1. Define Blueprint Properties

    identifier: service
    title: Service
    properties:
      - identifier: name
        type: string
        title: Name
      - identifier: description
        type: string
        title: Description
      - identifier: owner
        type: string
        title: Owner

  2. Add Required Fields

    • Choose mandatory properties
    • Set validation rules
    • Define default values

  3. Configure Relationships

    • Define entity connections
    • Set up dependency tracking
    • Configure ownership links

Adding Your First Entities​

  1. Create a Service Entity

    • Fill in basic information
    • Add documentation
    • Set up relationships

  2. Define Entity Properties

    • Add custom properties
    • Set up calculated fields
    • Configure validation

  3. Link Related Entities

    • Connect to other services
    • Define dependencies
    • Set up ownership

Understanding Relationships​

Port supports various relationship types:

  • Ownership: Who owns the service
  • Dependencies: What other services this depends on
  • Documentation: Links to relevant docs
  • Monitoring: Associated dashboards and alerts

Basic Catalog Navigation​

  1. Using the Search

    • Full-text search
    • Property filters
    • Relationship queries

  2. Viewing Entities

    • List view
    • Card view
    • Table view
    • Custom views

  3. Managing Updates

    • Manual updates
    • Automated sync
    • Change history

Hands-on Exercises​

Each module includes practical exercises to reinforce your learning:

  1. Create a Service Blueprint

    • Define a basic service blueprint
    • Add required properties
    • Set up relationships
    • Test the blueprint

  2. Add Catalog Entities

    • Create a new service
    • Add documentation
    • Set up monitoring links
    • Configure ownership

  3. Set Up Relationships

    • Connect services
    • Define dependencies
    • Create ownership links
    • Test relationship queries

  4. Practice Navigation

    • Use different views
    • Try advanced search
    • Filter and sort
    • Export data

Additional Resources​

Next Steps

After completing this course, we recommend:

Course Completion​

To complete this course:

  1. Work through all modules
  2. Complete the hands-on exercises
  3. Take the final assessment
  4. Receive your course completion certificate